@slicedearth/whoisleuth-cli 1.47.4 → 2.0.1

package/cli/artifact-structure.mjs

@@ -1,21 +1,26 @@
-import { ACQUISITION_DECISIONS, ACQUISITION_MANUAL_CHECKS, ACQUISITION_DECISION_PACKET_SCHEMA, ACQUISITION_DECISION_PACKET_VERSION, } from "../frontend/src/lib/analysis/acquisition-decision-packet.js";
-import { BULK_DOMAIN_COMPARISON_EXPORT_VERSION, BULK_DOMAIN_COMPARISON_SCHEMA, } from "../frontend/src/lib/analysis/bulk-domain-comparison.js";
-import { BULK_MAIL_EXPOSURE_EXPORT_VERSION, BULK_MAIL_EXPOSURE_SCHEMA, MAX_BULK_MAIL_EXPOSURE_ROWS, } from "../frontend/src/lib/analysis/bulk-mail-exposure.js";
-import { BULK_REVIEW_MANIFEST_SCHEMA, BULK_REVIEW_MANIFEST_VERSION, } from "../frontend/src/lib/analysis/bulk-review-export.js";
-import { CASE_RESPONSE_PACKET_SCHEMA, CASE_RESPONSE_PACKET_VERSION, LEGACY_CASE_RESPONSE_PACKET_VERSION, MAX_ABUSIVE_URLS, MAX_RESPONSE_ACTION_HISTORY, MAX_RESPONSE_CONTACTS, RESPONSE_PACKET_PROFILES, RESPONSE_CONTACT_KINDS, RESPONSE_PACKET_PROFILE_IDS, } from "../frontend/src/lib/analysis/case-response-packet.js";
-import { CASE_ACTION_STATES, CASE_ACTION_TYPES, MAX_DECISION_PIN_REFERENCES, MAX_CASE_ACTIONS, MAX_CASE_ASSERTIONS, MAX_CASE_DECISIONS, MAX_CASE_EVIDENCE_PINS, MAX_RESPONSE_LABEL_LENGTH, MAX_RESPONSE_LIMITATION_LENGTH, MAX_RESPONSE_LIMITATIONS, MAX_RESPONSE_RECIPIENT_LENGTH, } from "../frontend/src/lib/analysis/case-response-model.js";
-import { INVESTIGATION_CAPSULE_SCHEMA, INVESTIGATION_CAPSULE_VERSION, LEGACY_INVESTIGATION_CAPSULE_VERSION, } from "../frontend/src/lib/analysis/investigation-capsule.js";
-import { LOOKUP_INVESTIGATION_BRIEF_SCHEMA } from "../frontend/src/lib/analysis/lookup-investigation-brief.js";
-import { LOOKUP_CLAIM_PASSPORT_SCHEMA, LOOKUP_CLAIM_PASSPORT_TARGET_TYPES, LOOKUP_CLAIM_PASSPORT_VERSION, MAX_LOOKUP_CLAIM_PASSPORT_LIMITATIONS, MAX_LOOKUP_CLAIM_PASSPORT_REQUIREMENTS, } from "../frontend/src/lib/analysis/lookup-claim-passport.js";
-import { LOOKUP_CLAIM_IDS, LOOKUP_CLAIM_READINESS_VERSION, LOOKUP_CLAIM_REQUIREMENT_IDS, } from "../frontend/src/lib/analysis/lookup-claim-readiness.js";
-import { normalizeDomainControlPassportDocument } from "../frontend/src/lib/analysis/domain-control-manifest-core.js";
+import { createHash } from 'node:crypto';
+import { canonicalArtifactJsonV2 } from "../packages/evidence/artifact-integrity.mjs";
+import { ACQUISITION_DECISIONS, ACQUISITION_MANUAL_CHECKS, ACQUISITION_DECISION_PACKET_SCHEMA, ACQUISITION_DECISION_PACKET_VERSION, } from "../packages/investigation/acquisition-decision-packet.mjs";
+import { BULK_DOMAIN_COMPARISON_EXPORT_VERSION, BULK_DOMAIN_COMPARISON_SCHEMA, } from "../packages/investigation/bulk-domain-comparison.mjs";
+import { BULK_MAIL_EXPOSURE_EXPORT_VERSION, BULK_MAIL_EXPOSURE_SCHEMA, MAX_BULK_MAIL_EXPOSURE_ROWS, } from "../packages/investigation/bulk-mail-exposure.mjs";
+import { BULK_REVIEW_MANIFEST_SCHEMA, BULK_REVIEW_MANIFEST_VERSION, } from "../packages/investigation/bulk-review-export.mjs";
+import { CASE_RESPONSE_PACKET_SCHEMA, CASE_RESPONSE_PACKET_VERSION, PUBLIC_CASE_RESPONSE_PACKET_VERSION, CASE_RESPONSE_REVIEW_INPUTS_SCHEMA, CASE_RESPONSE_REVIEW_INPUTS_VERSION, MAX_ABUSIVE_URLS, MAX_RESPONSE_ARTEFACT_REFERENCES, MAX_RESPONSE_AUTHORISATION_CLOCK_SKEW_MS, MAX_RESPONSE_ACTION_HISTORY, MAX_RESPONSE_CONTACTS, MAX_RESPONSE_CONTRADICTIONS, MAX_RESPONSE_SELECTED_EVIDENCE, RESPONSE_AUTHORISATION_CONFIRMATION_IDS, RESPONSE_PACKET_PROFILES, RESPONSE_CONTACT_KINDS, RESPONSE_PACKET_PROFILE_IDS, RESPONSE_READINESS_ROW_IDS, RESPONSE_READINESS_STATES, RESPONSE_ROUTE_STALE_AFTER_DAYS, } from "../packages/cases/case-response-packet.mjs";
+import { CASE_ACTION_EVENT_SOURCE_CLASSES, CASE_ACTION_STATES, CASE_ACTION_TYPES, CASE_CLOSURE_REASONS, CASE_OBSERVED_EFFECT_SOURCE_CLASSES, CASE_OBSERVED_EFFECT_STATES, CASE_PROVIDER_OUTCOMES, isLegalCaseActionTransition, MAX_CASE_ACTION_EVENTS_PER_ACTION, MAX_DECISION_PIN_REFERENCES, MAX_CASE_ACTIONS, MAX_CASE_ASSERTIONS, MAX_CASE_DECISIONS, MAX_CASE_EVIDENCE_PINS, MAX_RESPONSE_LABEL_LENGTH, MAX_RESPONSE_LIMITATION_LENGTH, MAX_RESPONSE_LIMITATIONS, MAX_RESPONSE_RECIPIENT_LENGTH, } from "../packages/cases/case-response-model.mjs";
+import { INVESTIGATION_CAPSULE_ANALYST_RECORDS_SCHEMA, INVESTIGATION_CAPSULE_ANALYST_RECORDS_VERSION, INVESTIGATION_CAPSULE_SCHEMA, INVESTIGATION_CAPSULE_VERSION, PUBLIC_INVESTIGATION_CAPSULE_VERSION, } from "../packages/investigation/investigation-capsule.mjs";
+import { LOOKUP_ASSET_GRAPH_SCHEMA, LOOKUP_ASSET_GRAPH_VERSION, } from "../packages/investigation/lookup-asset-graph.mjs";
+import { PUBLIC_LOOKUP_INVESTIGATION_BRIEF_VERSION, LOOKUP_INVESTIGATION_BRIEF_SCHEMA, LOOKUP_INVESTIGATION_BRIEF_VERSION, MAX_LOOKUP_INVESTIGATION_BRIEF_BYTES, } from "../packages/investigation/lookup-investigation-brief.mjs";
+import { DECISION_FACT_CONSISTENCY_STATES, DECISION_FACT_EVIDENCE_STATES, DECISION_FACT_FRESHNESS_STATES, DECISION_FACT_PROVENANCE_STATES, DECISION_FACT_PROJECTION_VERSION, DECISION_FACT_VERSION, MAX_DECISION_FACT_CONTRIBUTORS, MAX_DECISION_FACT_CONTRADICTIONS, MAX_DECISION_FACT_LIMITATIONS, MAX_DECISION_FACT_NEXT_ACTIONS, MAX_DECISION_FACT_PROJECTION_CONTRADICTIONS, MAX_DECISION_FACT_PROJECTION_BYTES, MAX_DECISION_FACT_PROJECTION_FACTS, MAX_DECISION_FACT_PROJECTION_LIMITATIONS, MAX_DECISION_FACT_PROJECTION_NEXT_ACTIONS, MAX_DECISION_FACT_PROJECTION_REFERENCES, MAX_DECISION_FACT_PROJECTION_SOURCES, MAX_DECISION_FACT_PROJECTION_SOURCE_LIMITATIONS, MAX_DECISION_FACT_PROJECTION_SOURCE_REFERENCES, MAX_DECISION_FACT_REFERENCES, MAX_DECISION_FACTS, decisionFactCompleteness, } from "../packages/evidence/decision-fact.mjs";
+import { LOOKUP_CLAIM_PASSPORT_SCHEMA, LOOKUP_CLAIM_PASSPORT_TARGET_TYPES, LOOKUP_CLAIM_PASSPORT_VERSION, MAX_LOOKUP_CLAIM_PASSPORT_LIMITATIONS, MAX_LOOKUP_CLAIM_PASSPORT_REQUIREMENTS, } from "../packages/investigation/lookup-claim-passport.mjs";
+import { LOOKUP_CLAIM_IDS, LOOKUP_CLAIM_READINESS_VERSION, LOOKUP_CLAIM_REQUIREMENT_IDS, } from "../packages/investigation/lookup-claim-readiness.mjs";
+import { normalizeDomainControlManifestDocument } from "../packages/evidence/domain-control-runtime.mjs";
 import { DOMAIN_CHANGE_PACKET_SCHEMA, DOMAIN_CHANGE_PACKET_VERSION } from "../lib/domain-change-packet.mjs";
 import { DOMAIN_CONTROL_MANIFEST_SCHEMA } from "../lib/domain-control-manifest.mjs";
 import { INVESTIGATION_MANIFEST_SCHEMA, INVESTIGATION_MANIFEST_VERSION, MAX_INVESTIGATION_MANIFEST_ARTIFACTS, MAX_INVESTIGATION_MANIFEST_TOTAL_BYTES, } from "./investigation-manifest.mjs";
-import { assertLookupEvidencePrivacySafeTree, assertLookupEvidencePortableTree, LEGACY_LOOKUP_EVIDENCE_SCHEMA_VERSION, LOOKUP_EVIDENCE_SCHEMA, LOOKUP_EVIDENCE_SCHEMA_VERSION, projectLookupEvidenceAvailability, projectLookupEvidenceQuery, SUPPORTED_LOOKUP_EVIDENCE_SCHEMA_VERSIONS, } from "../lib/evidence-export.mjs";
+import { assertLookupEvidencePrivacySafeTree, assertLookupEvidencePortableTree, LOOKUP_EVIDENCE_SCHEMA, LOOKUP_EVIDENCE_SCHEMA_VERSION, PUBLIC_LOOKUP_EVIDENCE_SCHEMA_VERSION, projectLookupEvidenceAvailability, projectLookupEvidenceAvailabilityPublic, projectLookupEvidenceQuery, projectLookupEvidenceRdapPublication, projectLookupEvidenceRegistryInsights, projectLookupEvidenceWhoisPublication, SUPPORTED_LOOKUP_EVIDENCE_SCHEMA_VERSIONS, } from "../lib/evidence-export.mjs";
 import { compareRegistrySources } from "../lib/registry-comparison.mjs";
 import { buildRegistryInsights } from "../lib/registry-insights.mjs";
 import { WHOISLEUTH_SOURCE_REPOSITORY_URL } from "../lib/project-metadata.mjs";
+import { validHttpDeliveryMetadata, validPagePublicationMetadata, } from "../lib/homepage-metadata-contract.mjs";
 import { isDeepStrictEqual } from 'node:util';
 const CONTROL_RE = /[\u0000-\u001f\u007f]/u;
 const DIGEST_RE = /^sha256:[a-f0-9]{64}$/u;
@@ -124,7 +129,7 @@ const LOOKUP_TIMING_SOURCES = [
     'network_context', 'security_txt', 'external_intelligence',
     'malware_host_intelligence', 'malware_ioc_intelligence',
 ];
-const LOOKUP_AVAILABILITY_ANALYSIS_KEYS = [
+const PUBLIC_LOOKUP_AVAILABILITY_ANALYSIS_KEYS = [
     'applicable', 'type', 'domain', 'state', 'confidence', 'detail', 'source',
     'rdapServer', 'nameservers', 'statuses', 'registrar', 'registrant', 'abuse',
     'createdDate', 'expiryDate', 'createdDateIso', 'expiryDateIso', 'domainAgeDays',
@@ -137,11 +142,40 @@ const LOOKUP_AVAILABILITY_ANALYSIS_KEYS = [
     'securityPosture', 'dns', 'tls', 'hasMx', 'hasNullMx', 'mxHosts', 'hasSpf',
     'hasDmarc', 'bulkComparison', 'limitations',
 ];
+const LOOKUP_AVAILABILITY_ANALYSIS_KEYS = PUBLIC_LOOKUP_AVAILABILITY_ANALYSIS_KEYS.filter((key) => !['registrar', 'registrant', 'abuse'].includes(key));
 const LOOKUP_IDN_ANALYSIS_KEYS = [
     'version', 'mappingVersion', 'asciiDomain', 'unicodeDomain', 'hasIdn',
     'scripts', 'labels', 'mixedScript', 'skeleton', 'referenceMatches', 'findings',
     'truncated', 'limitations',
 ];
+function validateLookupEvidenceHomepageMetadata(availability, version) {
+    const pageIdentity = availability.pageIdentity === null || availability.pageIdentity === undefined
+        ? null
+        : record(availability.pageIdentity, 'Lookup evidence page identity');
+    const http = availability.http === null || availability.http === undefined
+        ? null
+        : record(availability.http, 'Lookup evidence HTTP analysis');
+    const response = http?.response === null || http?.response === undefined
+        ? null
+        : record(http.response, 'Lookup evidence HTTP response');
+    const publicationPresent = Boolean(pageIdentity && Object.hasOwn(pageIdentity, 'publicationMetadata'));
+    const deliveryPresent = Boolean(response && Object.hasOwn(response, 'deliveryMetadata'));
+    if (version < LOOKUP_EVIDENCE_SCHEMA_VERSION && (publicationPresent || deliveryPresent)) {
+        fail('Lookup evidence homepage metadata epoch');
+    }
+    if (publicationPresent && !validPagePublicationMetadata(pageIdentity?.publicationMetadata)) {
+        fail('Lookup evidence page publication metadata');
+    }
+    if (publicationPresent && !['success', 'partial'].includes(String(pageIdentity?.status))) {
+        fail('Lookup evidence page publication metadata source state');
+    }
+    if (deliveryPresent && !validHttpDeliveryMetadata(response?.deliveryMetadata)) {
+        fail('Lookup evidence HTTP delivery metadata');
+    }
+    if (deliveryPresent && !['success', 'partial'].includes(String(http?.status))) {
+        fail('Lookup evidence HTTP delivery metadata source state');
+    }
+}
 function validateLookupEvidenceRdapAttempt(value, label) {
     const attempt = exact(value, ['endpoint', 'transportSecurity', 'status', 'outcome', 'detail', 'selected'], label);
     let endpoint = null;
@@ -351,45 +385,40 @@ function validateLookupEvidenceRdap(value, version) {
         const error = exact(source, ['status', 'error', 'attempts'], 'Lookup evidence RDAP source');
         text(error.error, 'Lookup evidence RDAP error', 10_000);
         array(error.attempts, 'Lookup evidence RDAP attempts', 16).forEach((item, index) => {
-            if (version === LEGACY_LOOKUP_EVIDENCE_SCHEMA_VERSION)
-                record(item, `Lookup evidence legacy RDAP attempt ${index + 1}`);
-            else
-                validateLookupEvidenceRdapAttempt(item, `Lookup evidence RDAP attempt ${index + 1}`);
+            validateLookupEvidenceRdapAttempt(item, `Lookup evidence RDAP attempt ${index + 1}`);
         });
         return 'error';
     }
-    const complete = exact(source, ['status', 'endpoint', 'transportSecurity', 'httpStatus', 'fetchedAt', 'attempts', 'parsed', 'raw'], 'Lookup evidence RDAP source');
-    const status = enumeration(complete.status, version === LEGACY_LOOKUP_EVIDENCE_SCHEMA_VERSION
-        ? ['success', 'not_found']
-        : ['success', 'partial', 'not_found', 'unsupported', 'skipped', 'disabled'], 'Lookup evidence RDAP status');
+    const complete = exact(source, version >= LOOKUP_EVIDENCE_SCHEMA_VERSION
+        ? ['status', 'endpoint', 'transportSecurity', 'httpStatus', 'fetchedAt', 'attempts', 'parsed']
+        : ['status', 'endpoint', 'transportSecurity', 'httpStatus', 'fetchedAt', 'attempts', 'parsed', 'raw'], 'Lookup evidence RDAP source');
+    const status = enumeration(complete.status, ['success', 'partial', 'not_found', 'unsupported', 'skipped', 'disabled'], 'Lookup evidence RDAP status');
     let endpoint = null;
     if (complete.endpoint !== null)
         endpoint = absoluteUrl(complete.endpoint, 'Lookup evidence RDAP endpoint', ['http:', 'https:']);
     if (complete.transportSecurity !== null)
         enumeration(complete.transportSecurity, ['http', 'https'], 'Lookup evidence RDAP transport');
-    if (version !== LEGACY_LOOKUP_EVIDENCE_SCHEMA_VERSION) {
-        if (endpoint && complete.transportSecurity !== endpoint.protocol.slice(0, -1))
-            fail('Lookup evidence RDAP transport');
-        if (!endpoint && complete.transportSecurity !== null)
-            fail('Lookup evidence RDAP transport');
-    }
+    if (endpoint && complete.transportSecurity !== endpoint.protocol.slice(0, -1))
+        fail('Lookup evidence RDAP transport');
+    if (!endpoint && complete.transportSecurity !== null)
+        fail('Lookup evidence RDAP transport');
     if (complete.httpStatus !== null)
         integer(complete.httpStatus, 'Lookup evidence RDAP HTTP status', 100, 599);
     iso(complete.fetchedAt, 'Lookup evidence RDAP fetchedAt', true);
     array(complete.attempts, 'Lookup evidence RDAP attempts', 16).forEach((item, index) => {
-        if (version === LEGACY_LOOKUP_EVIDENCE_SCHEMA_VERSION)
-            record(item, `Lookup evidence legacy RDAP attempt ${index + 1}`);
-        else
-            validateLookupEvidenceRdapAttempt(item, `Lookup evidence RDAP attempt ${index + 1}`);
+        validateLookupEvidenceRdapAttempt(item, `Lookup evidence RDAP attempt ${index + 1}`);
     });
     nullableRecord(complete.parsed, 'Lookup evidence RDAP parsed data');
-    nullableRecord(complete.raw, 'Lookup evidence RDAP raw data');
-    if (version !== LEGACY_LOOKUP_EVIDENCE_SCHEMA_VERSION
-        && status === 'success' && complete.parsed === null)
+    if (version < LOOKUP_EVIDENCE_SCHEMA_VERSION)
+        nullableRecord(complete.raw, 'Lookup evidence RDAP raw data');
+    if (version >= LOOKUP_EVIDENCE_SCHEMA_VERSION
+        && !isDeepStrictEqual(complete.parsed, projectLookupEvidenceRdapPublication(complete.parsed))) {
+        fail('Lookup evidence RDAP portable publication');
+    }
+    if (status === 'success' && complete.parsed === null)
         fail('Lookup evidence RDAP publication');
-    if (version !== LEGACY_LOOKUP_EVIDENCE_SCHEMA_VERSION
-        && !['success', 'partial'].includes(status)
-        && (complete.parsed !== null || complete.raw !== null))
+    if (!['success', 'partial'].includes(status)
+        && (complete.parsed !== null || (version < LOOKUP_EVIDENCE_SCHEMA_VERSION && complete.raw !== null)))
         fail('Lookup evidence RDAP unavailable publication');
     return status;
 }
@@ -401,24 +430,22 @@ function validateLookupEvidenceWhois(value, version) {
         return 'error';
     }
     const complete = exact(source, ['status', 'queriedAt', 'authoritativeHop', 'failedHop', 'conflictingHop', 'parsed', 'chain'], 'Lookup evidence WHOIS source');
-    const status = enumeration(complete.status, version === LEGACY_LOOKUP_EVIDENCE_SCHEMA_VERSION
-        ? ['complete', 'partial', 'unknown']
-        : ['complete', 'partial', 'not_found', 'unsupported', 'skipped', 'disabled'], 'Lookup evidence WHOIS status');
+    const status = enumeration(complete.status, ['complete', 'partial', 'not_found', 'unsupported', 'skipped', 'disabled'], 'Lookup evidence WHOIS status');
     iso(complete.queriedAt, 'Lookup evidence WHOIS queriedAt', true);
     optionalText(complete.authoritativeHop, 'Lookup evidence WHOIS authoritative hop', 253);
     optionalText(complete.failedHop, 'Lookup evidence WHOIS failed hop', 253);
     optionalText(complete.conflictingHop, 'Lookup evidence WHOIS conflicting hop', 253);
     nullableRecord(complete.parsed, 'Lookup evidence WHOIS parsed data');
+    if (version >= LOOKUP_EVIDENCE_SCHEMA_VERSION
+        && !isDeepStrictEqual(complete.parsed, projectLookupEvidenceWhoisPublication(complete.parsed))) {
+        fail('Lookup evidence WHOIS portable publication');
+    }
     array(complete.chain, 'Lookup evidence WHOIS chain', 16).forEach((item, index) => {
-        if (version === LEGACY_LOOKUP_EVIDENCE_SCHEMA_VERSION)
-            record(item, `Lookup evidence legacy WHOIS chain item ${index + 1}`);
-        else
-            validateLookupEvidenceWhoisHop(item, `Lookup evidence WHOIS chain item ${index + 1}`);
+        validateLookupEvidenceWhoisHop(item, `Lookup evidence WHOIS chain item ${index + 1}`);
     });
     if (status === 'complete' && complete.parsed === null)
         fail('Lookup evidence WHOIS publication');
-    if (version !== LEGACY_LOOKUP_EVIDENCE_SCHEMA_VERSION
-        && !['complete', 'partial'].includes(status)
+    if (!['complete', 'partial'].includes(status)
         && (complete.parsed !== null || complete.chain.length !== 0))
         fail('Lookup evidence WHOIS unavailable publication');
     return status;
@@ -687,7 +714,7 @@ export function validateLookupEvidenceArtifactStructure(value) {
     if (root.schema !== LOOKUP_EVIDENCE_SCHEMA
         || !SUPPORTED_LOOKUP_EVIDENCE_SCHEMA_VERSIONS.includes(Number(root.schemaVersion)))
         fail('Lookup evidence');
-    const version = integer(root.schemaVersion, 'Lookup evidence version', LEGACY_LOOKUP_EVIDENCE_SCHEMA_VERSION, LOOKUP_EVIDENCE_SCHEMA_VERSION);
+    const version = integer(root.schemaVersion, 'Lookup evidence version', PUBLIC_LOOKUP_EVIDENCE_SCHEMA_VERSION, LOOKUP_EVIDENCE_SCHEMA_VERSION);
     iso(root.generatedAt, 'Lookup evidence generatedAt');
     const application = exact(root.application, ['name', 'version', 'projectUrl'], 'Lookup evidence application');
     if (application.name !== 'WHOISleuth' || application.projectUrl !== WHOISLEUTH_SOURCE_REPOSITORY_URL)
@@ -707,79 +734,45 @@ export function validateLookupEvidenceArtifactStructure(value) {
     }
     else if (query.inputHostname !== null || query.registrableDomain !== null || query.isSubdomain !== false)
         fail('Lookup evidence query');
-    if (version !== LEGACY_LOOKUP_EVIDENCE_SCHEMA_VERSION
-        && !isDeepStrictEqual(query, projectLookupEvidenceQuery(query)))
+    if (!isDeepStrictEqual(query, projectLookupEvidenceQuery(query)))
         fail('Lookup evidence query');
     let diagnostics;
     let rdapDiagnosticStatus;
     let whoisDiagnosticStatus;
-    let currentDiagnosticStates = null;
-    if (version === LEGACY_LOOKUP_EVIDENCE_SCHEMA_VERSION) {
-        diagnostics = exactOptional(root.diagnostics, ['rdap', 'whois'], ['version', 'availability', 'timing', 'registryAccess', 'reverseDns', 'network', 'securityTxt', 'sslbl'], 'Lookup evidence diagnostics');
-        if (diagnostics.version !== undefined)
-            integer(diagnostics.version, 'Lookup evidence diagnostics version', 1, 10);
-        const rdapDiagnostics = record(diagnostics.rdap, 'Lookup evidence rdap diagnostics');
-        const whoisDiagnostics = record(diagnostics.whois, 'Lookup evidence whois diagnostics');
-        rdapDiagnosticStatus = enumeration(rdapDiagnostics.status, ['success', 'partial', 'error', 'unsupported', 'not_found', 'skipped', 'disabled'], 'Lookup evidence RDAP diagnostic status');
-        whoisDiagnosticStatus = enumeration(whoisDiagnostics.status, ['complete', 'partial', 'error', 'unsupported', 'not_found', 'skipped', 'disabled'], 'Lookup evidence WHOIS diagnostic status');
-        for (const id of ['availability', 'timing', 'registryAccess', 'reverseDns', 'network', 'securityTxt', 'sslbl']) {
-            if (diagnostics[id] !== undefined)
-                record(diagnostics[id], `Lookup evidence ${id} diagnostics`);
-        }
-    }
-    else {
-        diagnostics = record(root.diagnostics, 'Lookup evidence diagnostics');
-        currentDiagnosticStates = validateLookupEvidenceCurrentDiagnostics(diagnostics);
-        rdapDiagnosticStatus = currentDiagnosticStates.rdap;
-        whoisDiagnosticStatus = currentDiagnosticStates.whois;
-    }
+    diagnostics = record(root.diagnostics, 'Lookup evidence diagnostics');
+    const currentDiagnosticStates = validateLookupEvidenceCurrentDiagnostics(diagnostics);
+    rdapDiagnosticStatus = currentDiagnosticStates.rdap;
+    whoisDiagnosticStatus = currentDiagnosticStates.whois;
     const sources = exact(root.sources, ['rdap', 'whois', 'reverseDns', 'network', 'securityTxt', 'sslbl'], 'Lookup evidence sources');
     const rdapSourceStatus = validateLookupEvidenceRdap(sources.rdap, version);
     const whoisSourceStatus = validateLookupEvidenceWhois(sources.whois, version);
-    if (version !== LEGACY_LOOKUP_EVIDENCE_SCHEMA_VERSION) {
-        if (rdapSourceStatus !== rdapDiagnosticStatus)
-            fail('Lookup evidence RDAP source state');
-        if (whoisSourceStatus !== whoisDiagnosticStatus)
-            fail('Lookup evidence WHOIS source state');
-    }
-    else {
-        const rdapSource = record(sources.rdap, 'Lookup evidence legacy RDAP source');
-        const whoisSource = record(sources.whois, 'Lookup evidence legacy WHOIS source');
-        if (rdapDiagnosticStatus === 'success'
-            && (rdapSourceStatus !== 'success' || rdapSource.parsed === null))
-            fail('Lookup evidence legacy RDAP source state');
-        if (rdapDiagnosticStatus === 'not_found' && rdapSourceStatus !== 'not_found')
-            fail('Lookup evidence legacy RDAP source state');
-        if (rdapDiagnosticStatus === 'error' && rdapSourceStatus !== 'error')
-            fail('Lookup evidence legacy RDAP source state');
-        if (whoisDiagnosticStatus === 'complete'
-            && (whoisSourceStatus !== 'complete' || whoisSource.parsed === null))
-            fail('Lookup evidence legacy WHOIS source state');
-        if (whoisDiagnosticStatus === 'partial'
-            && (whoisSourceStatus !== 'partial' || whoisSource.parsed === null))
-            fail('Lookup evidence legacy WHOIS source state');
-        if (whoisDiagnosticStatus === 'error' && whoisSourceStatus !== 'error')
-            fail('Lookup evidence legacy WHOIS source state');
-    }
+    if (rdapSourceStatus !== rdapDiagnosticStatus)
+        fail('Lookup evidence RDAP source state');
+    if (whoisSourceStatus !== whoisDiagnosticStatus)
+        fail('Lookup evidence WHOIS source state');
     const reverseDnsState = validateLookupEvidenceReverseDns(sources.reverseDns);
     const networkState = validateLookupEvidenceNetwork(sources.network);
-    if (currentDiagnosticStates) {
-        if (currentDiagnosticStates.reverseDns
-            && !isDeepStrictEqual(reverseDnsState, currentDiagnosticStates.reverseDns)) {
-            fail('Lookup evidence reverse DNS source state');
-        }
-        if (currentDiagnosticStates.network !== null
-            && (networkState?.status ?? null) !== currentDiagnosticStates.network) {
-            fail('Lookup evidence network source state');
-        }
+    if (currentDiagnosticStates.reverseDns
+        && !isDeepStrictEqual(reverseDnsState, currentDiagnosticStates.reverseDns)) {
+        fail('Lookup evidence reverse DNS source state');
+    }
+    if (currentDiagnosticStates.network !== null
+        && (networkState?.status ?? null) !== currentDiagnosticStates.network) {
+        fail('Lookup evidence network source state');
     }
     validateLookupEvidenceSecurityTxt(sources.securityTxt);
     validateLookupEvidenceSslbl(sources.sslbl);
     const analysis = exact(root.analysis, ['availability', 'idn', 'registryInsights', 'registryComparison', 'registrarPublicationComparison'], 'Lookup evidence analysis');
     if (analysis.availability !== null) {
-        exactOptional(analysis.availability, [], LOOKUP_AVAILABILITY_ANALYSIS_KEYS, 'Lookup evidence availability analysis');
-        if (version !== LEGACY_LOOKUP_EVIDENCE_SCHEMA_VERSION
-            && !isDeepStrictEqual(analysis.availability, projectLookupEvidenceAvailability(analysis.availability)))
+        const currentAvailability = version >= LOOKUP_EVIDENCE_SCHEMA_VERSION;
+        const availability = exactOptional(analysis.availability, currentAvailability ? ['registryContactsExcluded'] : [], currentAvailability ? LOOKUP_AVAILABILITY_ANALYSIS_KEYS : PUBLIC_LOOKUP_AVAILABILITY_ANALYSIS_KEYS, 'Lookup evidence availability analysis');
+        if (currentAvailability && availability.registryContactsExcluded !== true) {
+            fail('Lookup evidence availability contact exclusion');
+        }
+        validateLookupEvidenceHomepageMetadata(availability, version);
+        if (!isDeepStrictEqual(analysis.availability, currentAvailability
+            ? projectLookupEvidenceAvailability(analysis.availability)
+            : projectLookupEvidenceAvailabilityPublic(analysis.availability)))
             fail('Lookup evidence availability analysis');
     }
     if (analysis.idn !== null) {
@@ -788,7 +781,7 @@ export function validateLookupEvidenceArtifactStructure(value) {
     const registryInsights = record(analysis.registryInsights, 'Lookup evidence registry insights');
     const registryComparison = record(analysis.registryComparison, 'Lookup evidence registry comparison');
     validateLookupEvidenceRegistrarComparison(analysis.registrarPublicationComparison);
-    if (version !== LEGACY_LOOKUP_EVIDENCE_SCHEMA_VERSION) {
+    {
         const rdap = record(sources.rdap, 'Lookup evidence RDAP source');
         const whois = record(sources.whois, 'Lookup evidence WHOIS source');
         const rdapParsed = ['success', 'partial'].includes(rdapDiagnosticStatus) ? rdap.parsed : null;
@@ -799,7 +792,7 @@ export function validateLookupEvidenceArtifactStructure(value) {
         });
         if (!isDeepStrictEqual(registryComparison, expectedComparison))
             fail('Lookup evidence registry comparison derivation');
-        const expectedInsights = buildRegistryInsights({
+        const rebuiltInsights = buildRegistryInsights({
             rdapParsed,
             rdapStatus: rdapDiagnosticStatus,
             rdapFetchedAt: rdap.fetchedAt,
@@ -807,6 +800,9 @@ export function validateLookupEvidenceArtifactStructure(value) {
             whoisStatus: whoisDiagnosticStatus,
             whoisQueriedAt: whois.queriedAt,
         });
+        const expectedInsights = version >= LOOKUP_EVIDENCE_SCHEMA_VERSION
+            ? projectLookupEvidenceRegistryInsights(rebuiltInsights)
+            : rebuiltInsights;
         if (!isDeepStrictEqual(registryInsights, expectedInsights))
             fail('Lookup evidence registry insight derivation');
         try {
@@ -817,16 +813,11 @@ export function validateLookupEvidenceArtifactStructure(value) {
         }
     }
 }
-function validateIntegrity(value, label, version, legacyVersion, currentVersion, legacyExplicit = false) {
-    const explicit = version === currentVersion || (version === legacyVersion && legacyExplicit);
-    if (version !== legacyVersion && version !== currentVersion)
+function validateIntegrity(value, label, version, currentVersion) {
+    if (version !== currentVersion)
         fail(label);
-    const integrity = exact(value, explicit
-        ? ['algorithm', 'canonicalization', 'digestSha256']
-        : ['algorithm', 'digestSha256'], label);
-    if (integrity.algorithm !== 'SHA-256')
-        fail(label);
-    if (explicit && integrity.canonicalization !== (version === currentVersion ? 'sorted-json-v2' : 'sorted-json-v1'))
+    const integrity = exact(value, ['algorithm', 'canonicalization', 'digestSha256'], label);
+    if (integrity.algorithm !== 'SHA-256' || integrity.canonicalization !== 'sorted-json-v2')
         fail(label);
     digest(integrity.digestSha256, label);
 }
@@ -877,7 +868,7 @@ function validateAcquisition(value) {
     strings(evidence.nextSteps, 'Acquisition next steps', 6, 600);
     strings(evidence.limitations, 'Acquisition evidence limitations', 12, 600);
     strings(root.limitations, 'Acquisition limitations', 8, 600);
-    validateIntegrity(root.integrity, 'Acquisition integrity', root.version, 1, ACQUISITION_DECISION_PACKET_VERSION);
+    validateIntegrity(root.integrity, 'Acquisition integrity', root.version, ACQUISITION_DECISION_PACKET_VERSION);
 }
 const CLAIM_PASSPORT_SOURCE_STATES = ['complete', 'not_found', 'partial', 'skipped', 'unavailable', 'unknown', 'unsupported'];
 function validateClaimPassportTarget(type, value) {
@@ -971,7 +962,7 @@ function validateLookupClaimPassport(value) {
     if (models.risk !== null)
         integer(models.risk, 'Lookup claim passport Risk model', 1, 1_000);
     strings(root.limitations, 'Lookup claim passport limitations', MAX_LOOKUP_CLAIM_PASSPORT_LIMITATIONS, 600);
-    validateIntegrity(root.integrity, 'Lookup claim passport integrity', root.version, LOOKUP_CLAIM_PASSPORT_VERSION, LOOKUP_CLAIM_PASSPORT_VERSION);
+    validateIntegrity(root.integrity, 'Lookup claim passport integrity', root.version, LOOKUP_CLAIM_PASSPORT_VERSION);
 }
 const COMPARISON_STATES = ['conflicting', 'different', 'equal', 'missing', 'not_recorded', 'unavailable'];
 const SOURCE_STATES = ['complete', 'error', 'not_found', 'not_recorded', 'partial', 'skipped', 'unavailable', 'unsupported'];
@@ -1026,7 +1017,7 @@ function validateDomainComparison(value) {
             fail('Domain comparison counts');
     }
     strings(comparison.limitations, 'Domain comparison limitations', 12, 600);
-    validateIntegrity(root.integrity, 'Domain comparison integrity', root.version, 3, BULK_DOMAIN_COMPARISON_EXPORT_VERSION);
+    validateIntegrity(root.integrity, 'Domain comparison integrity', root.version, BULK_DOMAIN_COMPARISON_EXPORT_VERSION);
 }
 const MAIL_STATES = ['authenticated_mail', 'evidence_incomplete', 'mail_auth_gap', 'mail_auth_incomplete', 'no_explicit_mx', 'null_mx'];
 function validateSourceCoverage(value, label) {
@@ -1086,7 +1077,7 @@ function validateMailExposure(value) {
     if (declaredUnevaluated < unevaluated)
         fail('Bulk mail exposure unevaluated count');
     strings(report.limitations, 'Bulk mail exposure limitations', 12, 600);
-    validateIntegrity(root.integrity, 'Bulk mail exposure integrity', root.version, 1, BULK_MAIL_EXPOSURE_EXPORT_VERSION);
+    validateIntegrity(root.integrity, 'Bulk mail exposure integrity', root.version, BULK_MAIL_EXPOSURE_EXPORT_VERSION);
 }
 function validateBulkView(value, label) {
     const view = exact(value, ['primaryFilter', 'mutationFilter', 'signalFilters', 'sourceFilter', 'lifecycleFilter', 'ageFilter', 'mailFilter', 'registrarFilter', 'caseDispositionFilter', 'reviewStateFilter', 'groupBy', 'sortKey', 'sortDirection'], label);
@@ -1131,7 +1122,7 @@ function validateBulkReviewManifest(value) {
     if (rows.length !== domains.length)
         fail('Bulk review manifest selection');
     strings(root.limitations, 'Bulk review manifest limitations', 8, 600);
-    validateIntegrity(root.integrity, 'Bulk review manifest integrity', root.version, 1, BULK_REVIEW_MANIFEST_VERSION);
+    validateIntegrity(root.integrity, 'Bulk review manifest integrity', root.version, BULK_REVIEW_MANIFEST_VERSION);
 }
 function validateInvestigationManifest(value) {
     const root = exact(value, ['schema', 'version', 'generatedAt', 'application', 'workflow', 'configuration', 'artifacts', 'steps', 'summary', 'limitations', 'integrity'], 'Investigation manifest');
@@ -1168,9 +1159,21 @@ function validateInvestigationManifest(value) {
         || integer(summary.totalBytes, 'Investigation manifest total bytes', 1, MAX_INVESTIGATION_MANIFEST_TOTAL_BYTES) !== totalBytes)
         fail('Investigation manifest summary');
     strings(root.limitations, 'Investigation manifest limitations', 8, 600);
-    validateIntegrity(root.integrity, 'Investigation manifest integrity', root.version, 1, INVESTIGATION_MANIFEST_VERSION);
+    validateIntegrity(root.integrity, 'Investigation manifest integrity', root.version, INVESTIGATION_MANIFEST_VERSION);
 }
-function validateActionSummary(value, label) {
+const CASE_RESPONSE_PREFLIGHT_IDS = [
+    'required_incident_fields',
+    'evidence_pins',
+    'analyst_decision',
+    'recipient_route',
+    'profile_recipient',
+    'case_disposition',
+    'evidence_freshness',
+    'contradictory_evidence',
+    'action_tracking',
+];
+const PUBLIC_CASE_ACTION_STATES = ['planned', 'ready_for_review', 'submitted', 'acknowledged', 'resolved', 'closed'];
+function validatePublicActionSummary(value, label) {
     const summary = exact(value, ['total', 'active', 'submitted', 'acknowledged', 'resolved', 'closed', 'overdue', 'followUpDue', 'withOutcome', 'latestOutcomes'], label);
     const total = integer(summary.total, label, 0, MAX_CASE_ACTIONS);
     for (const key of ['active', 'submitted', 'acknowledged', 'resolved', 'closed', 'overdue', 'followUpDue', 'withOutcome'])
@@ -1182,22 +1185,11 @@ function validateActionSummary(value, label) {
         const outcome = exact(candidate, ['actionId', 'recipient', 'state', 'outcome', 'updatedAt'], label);
         text(outcome.actionId, label, 64);
         text(outcome.recipient, label, 320);
-        enumeration(outcome.state, CASE_ACTION_STATES, label);
+        enumeration(outcome.state, PUBLIC_CASE_ACTION_STATES, label);
         text(outcome.outcome, label, 2_000);
         iso(outcome.updatedAt, label);
     }
 }
-const CASE_RESPONSE_PREFLIGHT_IDS = [
-    'required_incident_fields',
-    'evidence_pins',
-    'analyst_decision',
-    'recipient_route',
-    'profile_recipient',
-    'case_disposition',
-    'evidence_freshness',
-    'contradictory_evidence',
-    'action_tracking',
-];
 function expectedObservationAge(observedAt, generatedAt) {
     const ageSeconds = Math.floor((Date.parse(generatedAt) - Date.parse(observedAt)) / 1_000);
     if (ageSeconds < -300)
@@ -1208,10 +1200,10 @@ function expectedObservationAge(observedAt, generatedAt) {
         return { ageSeconds, band: 'one_to_seven_days', refreshRecommended: false };
     return { ageSeconds, band: 'over_seven_days', refreshRecommended: true };
 }
-function validateCaseResponsePacket(value) {
+function validateCaseResponsePacketV6(value) {
     const root = exact(value, ['schema', 'schemaVersion', 'generatedAt', 'reviewRequired', 'submissionPerformed', 'profile', 'case', 'incident', 'contacts', 'preflight', 'escalationHistory', 'provenance', 'integrity'], 'Case-response packet');
-    if (root.schemaVersion !== LEGACY_CASE_RESPONSE_PACKET_VERSION && root.schemaVersion !== CASE_RESPONSE_PACKET_VERSION)
-        fail('Case-response packet');
+    if (root.schemaVersion !== PUBLIC_CASE_RESPONSE_PACKET_VERSION)
+        fail('Case-response packet v6');
     iso(root.generatedAt, 'Case-response packet generatedAt');
     if (root.reviewRequired !== true || root.submissionPerformed !== false)
         fail('Case-response packet review state');
@@ -1304,14 +1296,14 @@ function validateCaseResponsePacket(value) {
     const expectedStatus = actualCounts.block ? 'needs_input' : actualCounts.caution ? 'review_cautions' : 'ready_for_review';
     if (preflight.status !== expectedStatus || preflight.canExport !== (actualCounts.block === 0))
         fail('Case-response preflight status');
-    validateActionSummary(preflight.actionSummary, 'Case-response action summary');
+    validatePublicActionSummary(preflight.actionSummary, 'Case-response action summary');
     const history = array(root.escalationHistory, 'Case-response escalation history', MAX_RESPONSE_ACTION_HISTORY);
     for (const candidate of history) {
         const action = exact(candidate, ['type', 'recipient', 'contactSource', 'state', 'reference', 'outcome', 'createdAt', 'updatedAt'], 'Case-response escalation action');
         enumeration(action.type, CASE_ACTION_TYPES, 'Case-response action type');
         text(action.recipient, 'Case-response action recipient', 320, true);
         text(action.contactSource, 'Case-response action source', 120, true);
-        enumeration(action.state, CASE_ACTION_STATES, 'Case-response action state');
+        enumeration(action.state, PUBLIC_CASE_ACTION_STATES, 'Case-response action state');
         optionalText(action.reference, 'Case-response action reference', 500);
         optionalText(action.outcome, 'Case-response action outcome', 2_000);
         iso(action.createdAt, 'Case-response action createdAt');
@@ -1333,12 +1325,509 @@ function validateCaseResponsePacket(value) {
     strings(provenance.limitations, 'Case-response limitations', 8, 600);
     const integrity = exact(root.integrity, ['algorithm', 'canonicalization', 'scope', 'digestSha256'], 'Case-response integrity');
     if (integrity.algorithm !== 'SHA-256'
-        || integrity.canonicalization !== (root.schemaVersion === CASE_RESPONSE_PACKET_VERSION ? 'sorted-json-v2' : 'sorted-json-v1')
+        || integrity.canonicalization !== 'sorted-json-v2'
         || integrity.scope !== 'packet excluding integrity')
         fail('Case-response integrity');
     if (typeof integrity.digestSha256 !== 'string' || !HEX_DIGEST_RE.test(integrity.digestSha256))
         fail('Case-response integrity');
 }
+function validateCurrentActionSummary(value, label) {
+    const summary = exact(value, [
+        'total', 'active', 'drafting', 'readyForReview', 'reviewed', 'authorised', 'submitted',
+        'acknowledged', 'terminal', 'overdue', 'followUpDue', 'withProviderOutcome', 'latestOutcomes',
+    ], label);
+    const total = integer(summary.total, label, 0, MAX_CASE_ACTIONS);
+    const drafting = integer(summary.drafting, label, 0, total);
+    const ready = integer(summary.readyForReview, label, 0, total);
+    const reviewed = integer(summary.reviewed, label, 0, total);
+    const authorised = integer(summary.authorised, label, 0, total);
+    const submitted = integer(summary.submitted, label, 0, total);
+    const acknowledged = integer(summary.acknowledged, label, 0, total);
+    const terminal = integer(summary.terminal, label, 0, total);
+    const active = integer(summary.active, label, 0, total);
+    if (drafting + ready + reviewed + authorised + submitted + acknowledged + terminal !== total || active + terminal !== total)
+        fail(label);
+    for (const key of ['overdue', 'followUpDue', 'withProviderOutcome'])
+        integer(summary[key], label, 0, total);
+    const outcomes = array(summary.latestOutcomes, label, 5);
+    for (const candidate of outcomes) {
+        const outcome = exact(candidate, ['actionId', 'recipient', 'state', 'providerOutcome', 'outcomeDetail', 'occurredAt'], label);
+        text(outcome.actionId, label, 64);
+        text(outcome.recipient, label, 320);
+        enumeration(outcome.state, CASE_ACTION_STATES, label);
+        enumeration(outcome.providerOutcome, CASE_PROVIDER_OUTCOMES, label);
+        optionalText(outcome.outcomeDetail, label, 2_000);
+        iso(outcome.occurredAt, label);
+    }
+    return total;
+}
+function validateCaseResponsePacketV7(value) {
+    const root = exact(value, [
+        'schema', 'schemaVersion', 'generatedAt', 'reviewRequired', 'submissionPerformed', 'profile', 'case',
+        'incident', 'contacts', 'selectedEvidence', 'contradictions', 'readiness', 'artefactReferences',
+        'authorisation', 'preflight', 'escalationHistory', 'escalationHistoryOmitted',
+        'escalationHistoryLimitations', 'responseLifecycle', 'provenance', 'integrity',
+    ], 'Case-response packet v7');
+    if (root.schemaVersion !== CASE_RESPONSE_PACKET_VERSION)
+        fail('Case-response packet v7');
+    iso(root.generatedAt, 'Case-response packet generatedAt');
+    if (root.reviewRequired !== true || root.submissionPerformed !== false)
+        fail('Case-response packet review state');
+    const profile = exact(root.profile, ['id', 'label', 'audience', 'subject', 'checklist', 'evidenceOrder', 'includedEvidence', 'excludedEvidence', 'redactions', 'attachments', 'followUpFields'], 'Case-response profile');
+    const profileId = enumeration(profile.id, RESPONSE_PACKET_PROFILE_IDS, 'Case-response profile id');
+    text(profile.label, 'Case-response profile label', 200);
+    text(profile.audience, 'Case-response profile audience', 300);
+    text(profile.subject, 'Case-response profile subject', 500);
+    for (const key of ['checklist', 'evidenceOrder', 'includedEvidence', 'excludedEvidence', 'redactions', 'attachments', 'followUpFields'])
+        strings(profile[key], `Case-response profile ${key}`, 24, 500);
+    const selectedProfile = RESPONSE_PACKET_PROFILES.find((candidate) => candidate.id === profileId);
+    if (!selectedProfile
+        || profile.label !== selectedProfile.label
+        || profile.audience !== selectedProfile.audience
+        || !sameValues(profile.checklist, selectedProfile.checklist)
+        || !sameValues(profile.evidenceOrder, selectedProfile.evidenceOrder)
+        || !sameValues(profile.includedEvidence, selectedProfile.includedEvidence)
+        || !sameValues(profile.excludedEvidence, selectedProfile.excludedEvidence)
+        || !sameValues(profile.redactions, selectedProfile.redactions)
+        || !sameValues(profile.attachments, selectedProfile.attachments)
+        || !sameValues(profile.followUpFields, selectedProfile.followUpFields))
+        fail('Case-response profile');
+    const caseRecord = exact(root.case, ['id', 'domain', 'status', 'disposition', 'updatedAt'], 'Case-response case');
+    text(caseRecord.id, 'Case-response case id', 128);
+    domain(caseRecord.domain, 'Case-response case domain');
+    text(caseRecord.status, 'Case-response case status', 80);
+    text(caseRecord.disposition, 'Case-response case disposition', 80);
+    iso(caseRecord.updatedAt, 'Case-response case updatedAt');
+    const incident = exact(root.incident, ['category', 'affectedParty', 'abusiveUrls', 'observedHarm', 'observedAt'], 'Case-response incident');
+    text(incident.category, 'Case-response category', 80);
+    text(incident.affectedParty, 'Case-response affected party', 200);
+    const urls = strings(incident.abusiveUrls, 'Case-response abusive URLs', MAX_ABUSIVE_URLS, 2_048);
+    if (!urls.length || urls.some((item) => {
+        try {
+            const parsed = new URL(item);
+            return !['http:', 'https:'].includes(parsed.protocol) || Boolean(parsed.username || parsed.password) || parsed.toString() !== item;
+        }
+        catch {
+            return true;
+        }
+    }) || new Set(urls).size !== urls.length)
+        fail('Case-response abusive URLs');
+    text(incident.observedHarm, 'Case-response observed harm', 2_000);
+    iso(incident.observedAt, 'Case-response observedAt');
+    if (profile.subject !== `${selectedProfile?.subjectPrefix}: ${caseRecord.domain} (${incident.category})`)
+        fail('Case-response profile subject');
+    const contacts = array(root.contacts, 'Case-response contacts', MAX_RESPONSE_CONTACTS);
+    const contactKeys = new Set();
+    for (const candidate of contacts) {
+        const contact = exact(candidate, ['kind', 'contact', 'source', 'observedAt', 'freshness', 'limitations'], 'Case-response contact');
+        const kind = enumeration(contact.kind, RESPONSE_CONTACT_KINDS, 'Case-response contact kind');
+        const contactValue = text(contact.contact, 'Case-response contact value', MAX_RESPONSE_RECIPIENT_LENGTH);
+        const key = `${kind}\u0000${contactValue.toLowerCase()}`;
+        if (contactKeys.has(key))
+            fail('Case-response contacts');
+        contactKeys.add(key);
+        text(contact.source, 'Case-response contact source', 120);
+        iso(contact.observedAt, 'Case-response contact observedAt', true);
+        const freshness = enumeration(contact.freshness, ['current', 'stale', 'unknown'], 'Case-response contact freshness');
+        const routeAge = contact.observedAt === null
+            ? null
+            : Date.parse(root.generatedAt) - Date.parse(contact.observedAt);
+        const expectedFreshness = routeAge === null
+            ? 'unknown'
+            : routeAge < -300_000 || routeAge > RESPONSE_ROUTE_STALE_AFTER_DAYS * 86_400_000
+                ? 'stale'
+                : 'current';
+        if (freshness !== expectedFreshness)
+            fail('Case-response contact freshness');
+        strings(contact.limitations, 'Case-response contact limitations', MAX_RESPONSE_LIMITATIONS, MAX_RESPONSE_LIMITATION_LENGTH);
+    }
+    const evidence = array(root.selectedEvidence, 'Case-response selected evidence', MAX_RESPONSE_SELECTED_EVIDENCE);
+    const evidenceIds = new Set();
+    for (const candidate of evidence) {
+        const item = exact(candidate, ['id', 'label', 'source', 'observedAt', 'completeness', 'limitations'], 'Case-response selected evidence');
+        const id = text(item.id, 'Case-response evidence id', 64);
+        if (evidenceIds.has(id))
+            fail('Case-response selected evidence');
+        evidenceIds.add(id);
+        text(item.label, 'Case-response evidence label', 80);
+        text(item.source, 'Case-response evidence source', 120);
+        iso(item.observedAt, 'Case-response evidence observedAt');
+        enumeration(item.completeness, ['complete', 'partial', 'inconclusive', 'unknown'], 'Case-response evidence completeness');
+        strings(item.limitations, 'Case-response evidence limitations', 8, 240);
+    }
+    const contradictions = array(root.contradictions, 'Case-response contradictions', MAX_RESPONSE_CONTRADICTIONS);
+    const contradictionIds = new Set();
+    for (const candidate of contradictions) {
+        const item = exact(candidate, ['id', 'statement', 'state', 'limitations'], 'Case-response contradiction');
+        const id = text(item.id, 'Case-response contradiction id', 64);
+        if (contradictionIds.has(id))
+            fail('Case-response contradictions');
+        contradictionIds.add(id);
+        text(item.statement, 'Case-response contradiction statement', 2_000);
+        enumeration(item.state, ['open', 'resolved'], 'Case-response contradiction state');
+        strings(item.limitations, 'Case-response contradiction limitations', 8, 240);
+    }
+    const readiness = exact(root.readiness, ['profileId', 'rows', 'counts', 'limitations'], 'Case-response readiness');
+    if (readiness.profileId !== profileId)
+        fail('Case-response readiness profile');
+    const readinessRows = array(readiness.rows, 'Case-response readiness rows', RESPONSE_READINESS_ROW_IDS.length, RESPONSE_READINESS_ROW_IDS.length);
+    const actualReadiness = Object.fromEntries(RESPONSE_READINESS_STATES.map((state) => [state, 0]));
+    const requiredReadiness = new Set([
+        'observed_behaviour', 'exact_url', 'observation_time', 'capture_provenance', 'authority_review',
+        'selected_evidence', 'contradictions', 'source_limitations',
+        ...(profileId === 'internal_soc' ? [] : ['recipient_route']),
+        ...(['registrar', 'registry', 'network_hosting'].includes(profileId) ? ['infrastructure_responsibility'] : []),
+    ]);
+    const requiredContact = selectedProfile?.requiredContactKind
+        ? contacts.find((candidate) => candidate.kind === selectedProfile.requiredContactKind)
+        : contacts[0];
+    const expectedReadinessStates = {
+        observed_behaviour: 'complete',
+        exact_url: 'complete',
+        observation_time: expectedObservationAge(incident.observedAt, root.generatedAt).refreshRecommended ? 'stale' : 'complete',
+        capture_provenance: evidence.length ? 'complete' : 'unavailable',
+        recipient_route: !requiredContact
+            ? 'not_provided'
+            : requiredContact.freshness === 'stale'
+                ? 'stale'
+                : requiredContact.freshness === 'current' && requiredContact.source ? 'complete' : 'partial',
+        selected_evidence: !evidence.length
+            ? 'not_provided'
+            : evidence.every((candidate) => candidate.completeness === 'complete') ? 'complete' : 'partial',
+        ...(contradictions.length ? {
+            contradictions: contradictions.some((candidate) => candidate.state === 'open') ? 'partial' : 'complete',
+        } : {}),
+    };
+    for (const [index, candidate] of readinessRows.entries()) {
+        const row = exact(candidate, ['id', 'label', 'state', 'detail', 'requiredForAuthorisation', 'limitations'], 'Case-response readiness row');
+        if (row.id !== RESPONSE_READINESS_ROW_IDS[index])
+            fail('Case-response readiness row order');
+        text(row.label, 'Case-response readiness label', 200);
+        const state = enumeration(row.state, RESPONSE_READINESS_STATES, 'Case-response readiness state');
+        actualReadiness[state] = (actualReadiness[state] ?? 0) + 1;
+        text(row.detail, 'Case-response readiness detail', 500);
+        boolean(row.requiredForAuthorisation, 'Case-response readiness requirement');
+        if (row.requiredForAuthorisation !== requiredReadiness.has(row.id)
+            || (expectedReadinessStates[row.id] !== undefined
+                && row.state !== expectedReadinessStates[row.id]))
+            fail('Case-response readiness projection');
+        strings(row.limitations, 'Case-response readiness limitations', 8, 240);
+    }
+    const readinessCounts = exact(readiness.counts, [...RESPONSE_READINESS_STATES], 'Case-response readiness counts');
+    for (const state of RESPONSE_READINESS_STATES)
+        if (integer(readinessCounts[state], 'Case-response readiness count', 0, readinessRows.length) !== actualReadiness[state])
+            fail('Case-response readiness counts');
+    strings(readiness.limitations, 'Case-response readiness limitations', 8, 600);
+    const artefacts = array(root.artefactReferences, 'Case-response artefact references', MAX_RESPONSE_ARTEFACT_REFERENCES);
+    const artefactIds = new Set();
+    for (const candidate of artefacts) {
+        const item = exact(candidate, ['id', 'label', 'mediaType', 'capturedAt', 'source', 'digestSha256', 'byteLength', 'limitations'], 'Case-response artefact reference');
+        const id = text(item.id, 'Case-response artefact id', 64);
+        if (artefactIds.has(id))
+            fail('Case-response artefact references');
+        artefactIds.add(id);
+        text(item.label, 'Case-response artefact label', 120);
+        text(item.mediaType, 'Case-response artefact media type', 120);
+        iso(item.capturedAt, 'Case-response artefact capturedAt');
+        text(item.source, 'Case-response artefact source', 120);
+        if (typeof item.digestSha256 !== 'string' || !HEX_DIGEST_RE.test(item.digestSha256))
+            fail('Case-response artefact digest');
+        if (item.byteLength !== null)
+            integer(item.byteLength, 'Case-response artefact byte length', 0, 100 * 1024 * 1024);
+        strings(item.limitations, 'Case-response artefact limitations', 8, 240);
+    }
+    const authorisation = exact(root.authorisation, ['status', 'reviewedInputDigestSha256', 'suppliedReviewDigestSha256', 'digestMatches', 'confirmedAt', 'confirmations', 'missingConfirmations', 'limitations'], 'Case-response authorisation');
+    const authorisationStatus = enumeration(authorisation.status, ['draft', 'authorised'], 'Case-response authorisation status');
+    if (typeof authorisation.reviewedInputDigestSha256 !== 'string' || !HEX_DIGEST_RE.test(authorisation.reviewedInputDigestSha256))
+        fail('Case-response review digest');
+    if (authorisation.suppliedReviewDigestSha256 !== null && (typeof authorisation.suppliedReviewDigestSha256 !== 'string' || !HEX_DIGEST_RE.test(authorisation.suppliedReviewDigestSha256)))
+        fail('Case-response supplied review digest');
+    boolean(authorisation.digestMatches, 'Case-response authorisation digest match');
+    iso(authorisation.confirmedAt, 'Case-response authorisation confirmedAt', true);
+    if (authorisation.confirmedAt !== null
+        && Date.parse(authorisation.confirmedAt) > Date.parse(root.generatedAt) + MAX_RESPONSE_AUTHORISATION_CLOCK_SKEW_MS) {
+        fail('Case-response authorisation confirmedAt');
+    }
+    const confirmations = exact(authorisation.confirmations, [...RESPONSE_AUTHORISATION_CONFIRMATION_IDS], 'Case-response confirmations');
+    for (const id of RESPONSE_AUTHORISATION_CONFIRMATION_IDS)
+        boolean(confirmations[id], `Case-response confirmation ${id}`);
+    const missing = strings(authorisation.missingConfirmations, 'Case-response missing confirmations', RESPONSE_AUTHORISATION_CONFIRMATION_IDS.length, 80);
+    if (missing.some((id) => !RESPONSE_AUTHORISATION_CONFIRMATION_IDS.includes(id)))
+        fail('Case-response missing confirmations');
+    strings(authorisation.limitations, 'Case-response authorisation limitations', 8, 600);
+    const expectedMissing = RESPONSE_AUTHORISATION_CONFIRMATION_IDS.filter((id) => confirmations[id] !== true);
+    const expectedDigestMatches = authorisation.suppliedReviewDigestSha256 === authorisation.reviewedInputDigestSha256;
+    const missingRequiredReadiness = readinessRows.some((candidate) => {
+        const row = candidate;
+        return row.requiredForAuthorisation === true && (row.state === 'not_provided' || row.state === 'unavailable');
+    });
+    const authorityReady = readinessRows.some((candidate) => {
+        const row = candidate;
+        return row.id === 'authority_review' && row.state === 'complete';
+    });
+    if (authorisation.digestMatches !== expectedDigestMatches
+        || !sameValues(missing, expectedMissing)
+        || (authorisationStatus === 'authorised' && (authorisation.digestMatches !== true || authorisation.confirmedAt === null || missing.length || missingRequiredReadiness || !authorityReady))
+        || (authorisationStatus === 'draft' && authorisation.confirmedAt !== null))
+        fail('Case-response authorisation');
+    const preflight = exact(root.preflight, ['version', 'status', 'canExport', 'counts', 'checks', 'actionSummary'], 'Case-response preflight');
+    if (preflight.version !== 2)
+        fail('Case-response preflight');
+    const checks = array(preflight.checks, 'Case-response preflight checks', CASE_RESPONSE_PREFLIGHT_IDS.length, CASE_RESPONSE_PREFLIGHT_IDS.length);
+    const actualCounts = { block: 0, caution: 0, pass: 0 };
+    for (const [index, candidate] of checks.entries()) {
+        const check = exact(candidate, ['id', 'label', 'state', 'detail'], 'Case-response preflight check');
+        if (check.id !== CASE_RESPONSE_PREFLIGHT_IDS[index])
+            fail('Case-response preflight check order');
+        text(check.label, 'Case-response preflight label', 200);
+        const state = enumeration(check.state, ['block', 'caution', 'pass'], 'Case-response preflight state');
+        actualCounts[state] += 1;
+        text(check.detail, 'Case-response preflight detail', 1_000);
+    }
+    const counts = exact(preflight.counts, ['block', 'caution', 'pass'], 'Case-response preflight counts');
+    for (const state of ['block', 'caution', 'pass'])
+        if (integer(counts[state], 'Case-response preflight count', 0, checks.length) !== actualCounts[state])
+            fail('Case-response preflight counts');
+    const expectedStatus = actualCounts.block ? 'needs_input' : actualCounts.caution ? 'review_cautions' : 'ready_for_review';
+    if (preflight.status !== expectedStatus || preflight.canExport !== (actualCounts.block === 0))
+        fail('Case-response preflight status');
+    const actionTotal = validateCurrentActionSummary(preflight.actionSummary, 'Case-response action summary');
+    const history = array(root.escalationHistory, 'Case-response escalation history', MAX_RESPONSE_ACTION_HISTORY);
+    const escalationHistoryOmitted = integer(root.escalationHistoryOmitted, 'Case-response omitted actions', 0, MAX_CASE_ACTIONS);
+    const escalationHistoryLimitations = strings(root.escalationHistoryLimitations, 'Case-response history limitations', 4, 600);
+    if (history.length !== Math.min(actionTotal, MAX_RESPONSE_ACTION_HISTORY)
+        || escalationHistoryOmitted !== actionTotal - history.length
+        || (escalationHistoryOmitted > 0) !== (escalationHistoryLimitations.length > 0))
+        fail('Case-response action-history bounds');
+    const actionIds = new Set();
+    const providerEvents = [];
+    for (const candidate of history) {
+        const action = exact(candidate, ['actionId', 'type', 'recipient', 'contactSource', 'state', 'reference', 'providerOutcome', 'outcomeDetail', 'originActionId', 'historyOmitted', 'historyLimitations', 'transitions', 'createdAt', 'updatedAt'], 'Case-response escalation action');
+        const actionId = text(action.actionId, 'Case-response action id', 64);
+        if (actionIds.has(actionId))
+            fail('Case-response action identity');
+        actionIds.add(actionId);
+        enumeration(action.type, CASE_ACTION_TYPES, 'Case-response action type');
+        text(action.recipient, 'Case-response action recipient', 320);
+        text(action.contactSource, 'Case-response action source', 120);
+        enumeration(action.state, CASE_ACTION_STATES, 'Case-response action state');
+        optionalText(action.reference, 'Case-response action reference', 500);
+        if (action.providerOutcome !== null)
+            enumeration(action.providerOutcome, CASE_PROVIDER_OUTCOMES, 'Case-response provider outcome');
+        optionalText(action.outcomeDetail, 'Case-response action outcome detail', 2_000);
+        optionalText(action.originActionId, 'Case-response action origin', 64);
+        integer(action.historyOmitted, 'Case-response action omitted history', 0, 1_000_000);
+        strings(action.historyLimitations, 'Case-response action history limitations', 8, 240);
+        const transitions = array(action.transitions, 'Case-response action transitions', MAX_CASE_ACTION_EVENTS_PER_ACTION, 1);
+        const eventIds = new Set();
+        let projectedState = null;
+        let latestReference = null;
+        let latestProviderOutcome = null;
+        let latestProviderOutcomeDetail = null;
+        let latestOutcomeDetail = null;
+        let previousTime = Number.NEGATIVE_INFINITY;
+        let previousEventId = '';
+        for (const eventCandidate of transitions) {
+            const event = exact(eventCandidate, ['id', 'previousState', 'nextState', 'occurredAt', 'sourceClass', 'provenance', 'reference', 'evidencePinId', 'limitations', 'providerOutcome', 'outcomeDetail', 'originActionId', 'applied'], 'Case-response action transition');
+            const eventId = text(event.id, 'Case-response action event id', 64);
+            if (eventIds.has(eventId))
+                fail('Case-response action event identity');
+            eventIds.add(eventId);
+            const previousState = event.previousState === null ? null : enumeration(event.previousState, CASE_ACTION_STATES, 'Case-response previous state');
+            const nextState = enumeration(event.nextState, CASE_ACTION_STATES, 'Case-response next state');
+            iso(event.occurredAt, 'Case-response action event time');
+            const eventTime = Date.parse(event.occurredAt);
+            if (eventTime < previousTime || (eventTime === previousTime && eventId < previousEventId))
+                fail('Case-response action event order');
+            previousTime = eventTime;
+            previousEventId = eventId;
+            const sourceClass = enumeration(event.sourceClass, CASE_ACTION_EVENT_SOURCE_CLASSES, 'Case-response action event source class');
+            text(event.provenance, 'Case-response action event provenance', 80);
+            optionalText(event.reference, 'Case-response action event reference', 500);
+            optionalText(event.evidencePinId, 'Case-response action event evidence pin', 64);
+            strings(event.limitations, 'Case-response action event limitations', 8, 240);
+            const providerOutcome = event.providerOutcome === null ? null : enumeration(event.providerOutcome, CASE_PROVIDER_OUTCOMES, 'Case-response action event provider outcome');
+            if (providerOutcome !== null && !['submitted', 'acknowledged', 'terminal'].includes(nextState) && sourceClass !== 'migration')
+                fail('Case-response action event provider outcome');
+            const migrationSnapshot = sourceClass === 'migration' && previousState === null;
+            if (providerOutcome !== null && previousState === 'authorised' && nextState === 'submitted' && !migrationSnapshot)
+                fail('Case-response submission event outcome');
+            if (providerOutcome === 'no_response' && sourceClass === 'provider')
+                fail('Case-response no-response event source');
+            if (['ready_for_review', 'reviewed', 'authorised', 'submitted'].includes(nextState)
+                && sourceClass !== 'analyst' && !migrationSnapshot)
+                fail('Case-response explicit analyst transition');
+            if (nextState === 'terminal' && previousState !== null
+                && ['drafting', 'ready_for_review', 'reviewed', 'authorised'].includes(previousState)
+                && (sourceClass !== 'analyst' || providerOutcome !== 'withdrawn'))
+                fail('Case-response early terminal transition');
+            if (providerOutcome === 'withdrawn'
+                && (nextState !== 'terminal' || (sourceClass !== 'analyst' && !migrationSnapshot)))
+                fail('Case-response withdrawn transition');
+            optionalText(event.outcomeDetail, 'Case-response action event outcome detail', 2_000);
+            optionalText(event.originActionId, 'Case-response action event origin', 64);
+            if (event.originActionId === actionId)
+                fail('Case-response action event origin');
+            boolean(event.applied, 'Case-response action event projection');
+            const applied = event.applied;
+            if (providerOutcome !== null) {
+                providerEvents.push({
+                    actionId,
+                    eventId,
+                    outcome: providerOutcome,
+                    occurredAt: event.occurredAt,
+                    reference: event.reference,
+                    applied,
+                });
+            }
+            if (projectedState === null && Number(action.historyOmitted) > 0 && previousState !== null)
+                projectedState = previousState;
+            const expectedApplied = previousState === projectedState
+                && isLegalCaseActionTransition(previousState, nextState, sourceClass);
+            if (applied !== expectedApplied)
+                fail('Case-response action event projection');
+            if (applied) {
+                projectedState = nextState;
+                if (event.reference !== null)
+                    latestReference = event.reference;
+                if (event.outcomeDetail !== null)
+                    latestOutcomeDetail = event.outcomeDetail;
+                if (providerOutcome !== null) {
+                    latestProviderOutcome = providerOutcome;
+                    latestProviderOutcomeDetail = event.outcomeDetail;
+                }
+            }
+        }
+        if ((projectedState ?? 'drafting') !== action.state
+            || latestReference !== action.reference
+            || latestProviderOutcome !== action.providerOutcome
+            || (latestProviderOutcomeDetail ?? latestOutcomeDetail) !== action.outcomeDetail)
+            fail('Case-response action projection');
+        if (action.originActionId === actionId)
+            fail('Case-response action origin');
+        iso(action.createdAt, 'Case-response action createdAt');
+        iso(action.updatedAt, 'Case-response action updatedAt');
+    }
+    const lifecycle = exact(root.responseLifecycle, ['providerOutcomeState', 'latestProviderOutcome', 'observedChangeState', 'latestObservedEffect', 'latestObservedChangeAt', 'closure', 'limitations'], 'Case-response lifecycle');
+    const providerOutcomeState = enumeration(lifecycle.providerOutcomeState, ['available', 'missing', 'ambiguous'], 'Case-response lifecycle provider state');
+    let actualLatestProvider = null;
+    if (lifecycle.latestProviderOutcome !== null) {
+        const outcome = exact(lifecycle.latestProviderOutcome, ['actionId', 'eventId', 'outcome', 'occurredAt', 'reference'], 'Case-response lifecycle provider outcome');
+        const actionId = text(outcome.actionId, 'Case-response lifecycle action id', 64);
+        const eventId = text(outcome.eventId, 'Case-response lifecycle event id', 64);
+        const providerOutcome = enumeration(outcome.outcome, CASE_PROVIDER_OUTCOMES, 'Case-response lifecycle provider outcome');
+        iso(outcome.occurredAt, 'Case-response lifecycle provider time');
+        const occurredAt = outcome.occurredAt;
+        optionalText(outcome.reference, 'Case-response lifecycle reference', 500);
+        actualLatestProvider = {
+            actionId,
+            eventId,
+            outcome: providerOutcome,
+            occurredAt,
+            reference: outcome.reference,
+        };
+    }
+    providerEvents.sort((left, right) => Date.parse(right.occurredAt) - Date.parse(left.occurredAt)
+        || (right.eventId < left.eventId ? -1 : right.eventId > left.eventId ? 1 : 0));
+    const latestProviderTime = providerEvents[0]?.occurredAt ?? null;
+    const latestProviderEvents = latestProviderTime === null
+        ? []
+        : providerEvents.filter((event) => event.occurredAt === latestProviderTime);
+    const expectedLatestProvider = escalationHistoryOmitted === 0
+        && latestProviderEvents.length === 1 && latestProviderEvents[0].applied
+        ? latestProviderEvents[0]
+        : null;
+    const expectedProviderState = escalationHistoryOmitted > 0
+        ? 'ambiguous'
+        : providerEvents.length === 0 ? 'missing' : expectedLatestProvider ? 'available' : 'ambiguous';
+    if (providerOutcomeState !== expectedProviderState
+        || (actualLatestProvider === null) !== (expectedLatestProvider === null)
+        || (actualLatestProvider && expectedLatestProvider && (actualLatestProvider.actionId !== expectedLatestProvider.actionId
+            || actualLatestProvider.eventId !== expectedLatestProvider.eventId
+            || actualLatestProvider.outcome !== expectedLatestProvider.outcome
+            || actualLatestProvider.occurredAt !== expectedLatestProvider.occurredAt
+            || actualLatestProvider.reference !== expectedLatestProvider.reference)))
+        fail('Case-response lifecycle provider state');
+    const observedChangeState = enumeration(lifecycle.observedChangeState, ['available', 'missing', 'ambiguous'], 'Case-response lifecycle observed-change state');
+    if (lifecycle.latestObservedEffect !== null) {
+        const effect = exact(lifecycle.latestObservedEffect, ['reviewId', 'state', 'observedAt', 'sourceClass', 'source'], 'Case-response lifecycle observed effect');
+        text(effect.reviewId, 'Case-response effect review id', 64);
+        enumeration(effect.state, CASE_OBSERVED_EFFECT_STATES, 'Case-response effect state');
+        iso(effect.observedAt, 'Case-response effect observedAt');
+        enumeration(effect.sourceClass, CASE_OBSERVED_EFFECT_SOURCE_CLASSES, 'Case-response effect source class');
+        text(effect.source, 'Case-response effect source', 80);
+    }
+    iso(lifecycle.latestObservedChangeAt, 'Case-response observed change time', true);
+    if ((observedChangeState === 'available') !== (lifecycle.latestObservedChangeAt !== null))
+        fail('Case-response lifecycle observed-change state');
+    if (lifecycle.closure !== null) {
+        const closure = exact(lifecycle.closure, ['id', 'reason', 'createdAt', 'limitations'], 'Case-response closure');
+        text(closure.id, 'Case-response closure id', 64);
+        enumeration(closure.reason, CASE_CLOSURE_REASONS, 'Case-response closure reason');
+        iso(closure.createdAt, 'Case-response closure time');
+        strings(closure.limitations, 'Case-response closure limitations', 8, 240);
+    }
+    strings(lifecycle.limitations, 'Case-response lifecycle limitations', 8, 600);
+    const reviewedInputs = {
+        contract: CASE_RESPONSE_REVIEW_INPUTS_SCHEMA,
+        version: CASE_RESPONSE_REVIEW_INPUTS_VERSION,
+        profile: {
+            id: profile.id,
+            label: profile.label,
+            audience: profile.audience,
+            subject: profile.subject,
+            checklist: profile.checklist,
+            includedEvidence: profile.includedEvidence,
+            excludedEvidence: profile.excludedEvidence,
+            redactions: profile.redactions,
+        },
+        case: root.case,
+        incident: root.incident,
+        contacts: root.contacts,
+        selectedEvidence: root.selectedEvidence,
+        contradictions: root.contradictions,
+        readiness: root.readiness,
+        artefactReferences: root.artefactReferences,
+        escalationHistory: root.escalationHistory,
+        escalationHistoryOmitted: root.escalationHistoryOmitted,
+        escalationHistoryLimitations: root.escalationHistoryLimitations,
+        responseLifecycle: root.responseLifecycle,
+    };
+    const expectedReviewDigest = createHash('sha256')
+        .update(canonicalArtifactJsonV2(reviewedInputs))
+        .digest('hex');
+    if (authorisation.reviewedInputDigestSha256 !== expectedReviewDigest)
+        fail('Case-response reviewed-input digest');
+    const provenance = exact(root.provenance, ['latestEvidenceCapturedAt', 'evidencePinCount', 'decisionCount', 'assertionCount', 'observationAge', 'limitations'], 'Case-response provenance');
+    iso(provenance.latestEvidenceCapturedAt, 'Case-response evidence time', true);
+    integer(provenance.evidencePinCount, 'Case-response evidence pin count', 0, MAX_CASE_EVIDENCE_PINS);
+    integer(provenance.decisionCount, 'Case-response decision count', 0, MAX_CASE_DECISIONS);
+    integer(provenance.assertionCount, 'Case-response assertion count', 0, MAX_CASE_ASSERTIONS);
+    const age = exact(provenance.observationAge, ['ageSeconds', 'band', 'refreshRecommended'], 'Case-response observation age');
+    integer(age.ageSeconds, 'Case-response observation age seconds', Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+    enumeration(age.band, ['future_or_clock_skew', 'one_to_seven_days', 'over_seven_days', 'under_24_hours'], 'Case-response observation age band');
+    boolean(age.refreshRecommended, 'Case-response refresh recommendation');
+    const expectedAge = expectedObservationAge(incident.observedAt, root.generatedAt);
+    if (age.ageSeconds !== expectedAge.ageSeconds || age.band !== expectedAge.band || age.refreshRecommended !== expectedAge.refreshRecommended)
+        fail('Case-response observation age');
+    strings(provenance.limitations, 'Case-response limitations', 8, 600);
+    const integrity = exact(root.integrity, ['algorithm', 'canonicalization', 'scope', 'digestSha256'], 'Case-response integrity');
+    if (integrity.algorithm !== 'SHA-256' || integrity.canonicalization !== 'sorted-json-v2' || integrity.scope !== 'packet excluding integrity')
+        fail('Case-response integrity');
+    if (typeof integrity.digestSha256 !== 'string' || !HEX_DIGEST_RE.test(integrity.digestSha256))
+        fail('Case-response integrity');
+}
+function validateCaseResponsePacket(value) {
+    if (value.schemaVersion === PUBLIC_CASE_RESPONSE_PACKET_VERSION)
+        return validateCaseResponsePacketV6(value);
+    if (Number.isSafeInteger(value.schemaVersion) && value.schemaVersion < CASE_RESPONSE_PACKET_VERSION) {
+        throw new TypeError(`Case-response packet version ${String(value.schemaVersion)} is not part of the public compatibility boundary; no data was changed.`);
+    }
+    if (Number.isSafeInteger(value.schemaVersion) && value.schemaVersion > CASE_RESPONSE_PACKET_VERSION) {
+        throw new TypeError(`Case-response packet version ${String(value.schemaVersion)} is newer than the supported version ${CASE_RESPONSE_PACKET_VERSION}; no data was changed.`);
+    }
+    validateCaseResponsePacketV7(value);
+}
 function validateBriefFact(value, label) {
     const fact = exact(value, ['label', 'value', 'detail', 'provenance'], label);
     text(fact.label, label, 320);
@@ -1365,9 +1854,10 @@ function validateDecisionEntry(value, label) {
     if (typeof entry.href !== 'string' || !/^#[^\u0000-\u001f\u007f]{1,160}$/u.test(entry.href))
         fail(label);
 }
-function validateBrief(value) {
+function validatePublicBrief(value) {
     const brief = exact(value, ['schema', 'schemaVersion', 'generatedAt', 'target', 'targetType', 'task', 'taskLabel', 'question', 'summary', 'observation', 'verifiedFacts', 'contradictions', 'unknowns', 'nextActions', 'relationships', 'limitations'], 'Investigation capsule brief');
-    if (brief.schema !== LOOKUP_INVESTIGATION_BRIEF_SCHEMA || brief.schemaVersion !== 1)
+    if (brief.schema !== LOOKUP_INVESTIGATION_BRIEF_SCHEMA
+        || brief.schemaVersion !== PUBLIC_LOOKUP_INVESTIGATION_BRIEF_VERSION)
         fail('Investigation capsule brief');
     iso(brief.generatedAt, 'Investigation capsule brief generatedAt');
     text(brief.target, 'Investigation capsule brief target', 253);
@@ -1411,9 +1901,191 @@ function validateBrief(value) {
     strings(relationships.kinds, 'Investigation capsule relationship kinds', 12, 320);
     strings(brief.limitations, 'Investigation capsule brief limitations', 20, 320);
 }
+function validateProjectionCollection(value, label, totalMaximum, displayedMaximum, validateItem) {
+    const collection = exact(value, ['total', 'displayed', 'omitted', 'items'], label);
+    const total = integer(collection.total, `${label} total`, 0, totalMaximum);
+    const displayed = integer(collection.displayed, `${label} displayed`, 0, displayedMaximum);
+    const omitted = integer(collection.omitted, `${label} omitted`, 0, totalMaximum);
+    const items = array(collection.items, `${label} items`, displayedMaximum);
+    if (displayed > total || omitted !== total - displayed || items.length !== displayed)
+        fail(label);
+    items.forEach(validateItem);
+    return { total, displayed, omitted, items };
+}
+function validateSortedUnique(values, label) {
+    for (let index = 0; index < values.length; index += 1) {
+        if (index > 0 && values[index - 1] >= values[index])
+            fail(label);
+    }
+}
+function validateDecisionIdentifier(value, label) {
+    const identifier = text(value, label, 200);
+    if (!/^[a-z0-9](?:[a-z0-9._:-]{0,199})$/u.test(identifier))
+        fail(label);
+    return identifier;
+}
+function validateProjectedStringCollection(value, label, totalMaximum, displayedMaximum, textMaximum) {
+    const projection = validateProjectionCollection(value, label, totalMaximum, displayedMaximum, (item) => { text(item, `${label} item`, textMaximum); });
+    validateSortedUnique(projection.items, label);
+    return projection;
+}
+function validateDecisionFactSource(value, label) {
+    const source = exact(value, [
+        'id',
+        'label',
+        'provenance',
+        'evidenceState',
+        'observedAt',
+        'references',
+        'limitations',
+    ], label);
+    const id = validateDecisionIdentifier(source.id, `${label} id`);
+    text(source.label, `${label} label`, 160);
+    enumeration(source.provenance, DECISION_FACT_PROVENANCE_STATES, `${label} provenance`);
+    enumeration(source.evidenceState, DECISION_FACT_EVIDENCE_STATES, `${label} evidence state`);
+    iso(source.observedAt, `${label} observation time`, true);
+    validateProjectedStringCollection(source.references, `${label} references`, MAX_DECISION_FACT_REFERENCES, MAX_DECISION_FACT_PROJECTION_SOURCE_REFERENCES, 200);
+    validateProjectedStringCollection(source.limitations, `${label} limitations`, MAX_DECISION_FACT_LIMITATIONS, MAX_DECISION_FACT_PROJECTION_SOURCE_LIMITATIONS, 280);
+    return id;
+}
+function validateProjectedDecisionFact(value, label) {
+    const fact = exact(value, [
+        'version',
+        'id',
+        'question',
+        'conclusion',
+        'importance',
+        'evidenceState',
+        'completeness',
+        'freshness',
+        'consistency',
+        'dependencies',
+        'sourceReferences',
+        'sources',
+        'contradictions',
+        'limitations',
+        'safeNextActions',
+    ], label);
+    if (fact.version !== DECISION_FACT_VERSION)
+        fail(`${label} version`);
+    const id = validateDecisionIdentifier(fact.id, `${label} id`);
+    text(fact.question, `${label} question`, 320);
+    text(fact.conclusion, `${label} conclusion`, 640);
+    enumeration(fact.importance, ['high', 'medium', 'low'], `${label} importance`);
+    const evidenceState = enumeration(fact.evidenceState, DECISION_FACT_EVIDENCE_STATES, `${label} evidence state`);
+    if (fact.completeness !== decisionFactCompleteness(evidenceState))
+        fail(`${label} completeness`);
+    enumeration(fact.freshness, DECISION_FACT_FRESHNESS_STATES, `${label} freshness`);
+    const consistency = enumeration(fact.consistency, DECISION_FACT_CONSISTENCY_STATES, `${label} consistency`);
+    const dependencies = validateProjectedStringCollection(fact.dependencies, `${label} dependencies`, MAX_DECISION_FACT_CONTRIBUTORS, MAX_DECISION_FACT_PROJECTION_SOURCES, 200);
+    dependencies.items.forEach((item) => validateDecisionIdentifier(item, `${label} dependency`));
+    validateProjectedStringCollection(fact.sourceReferences, `${label} source references`, MAX_DECISION_FACT_REFERENCES, MAX_DECISION_FACT_PROJECTION_REFERENCES, 200);
+    const sourceIds = [];
+    const sources = validateProjectionCollection(fact.sources, `${label} sources`, MAX_DECISION_FACT_CONTRIBUTORS, MAX_DECISION_FACT_PROJECTION_SOURCES, (item, index) => { sourceIds.push(validateDecisionFactSource(item, `${label} source ${index + 1}`)); });
+    validateSortedUnique(sourceIds, `${label} sources`);
+    if (dependencies.total !== sources.total
+        || dependencies.displayed !== sources.displayed
+        || dependencies.omitted !== sources.omitted
+        || !sameValues(dependencies.items, sourceIds))
+        fail(`${label} dependencies`);
+    validateProjectedStringCollection(fact.contradictions, `${label} contradictions`, MAX_DECISION_FACT_CONTRADICTIONS, MAX_DECISION_FACT_PROJECTION_CONTRADICTIONS, 640);
+    validateProjectedStringCollection(fact.limitations, `${label} limitations`, MAX_DECISION_FACT_LIMITATIONS, MAX_DECISION_FACT_PROJECTION_LIMITATIONS, 280);
+    const actionIds = [];
+    validateProjectionCollection(fact.safeNextActions, `${label} safe next actions`, MAX_DECISION_FACT_NEXT_ACTIONS, MAX_DECISION_FACT_PROJECTION_NEXT_ACTIONS, (candidate, index) => {
+        const action = exact(candidate, ['id', 'label', 'reason', 'expectedOutcome', 'href', 'importance'], `${label} safe next action ${index + 1}`);
+        actionIds.push(validateDecisionIdentifier(action.id, `${label} safe next action id`));
+        text(action.label, `${label} safe next action label`, 160);
+        text(action.reason, `${label} safe next action reason`, 320);
+        text(action.expectedOutcome, `${label} safe next action outcome`, 320);
+        if (typeof action.href !== 'string' || !/^#[a-z0-9](?:[a-z0-9._:-]{0,159})$/u.test(action.href))
+            fail(`${label} safe next action href`);
+        enumeration(action.importance, ['high', 'medium', 'low'], `${label} safe next action importance`);
+    });
+    validateSortedUnique(actionIds, `${label} safe next actions`);
+    return { id, consistency };
+}
+function validateDecisionFactProjection(value) {
+    const projection = exact(value, [
+        'version',
+        'total',
+        'displayed',
+        'omitted',
+        'contradictory',
+        'unresolved',
+        'facts',
+    ], 'Investigation capsule Decision Fact projection');
+    if (projection.version !== DECISION_FACT_PROJECTION_VERSION)
+        fail('Investigation capsule Decision Fact projection');
+    const total = integer(projection.total, 'Investigation capsule Decision Fact total', 0, MAX_DECISION_FACTS);
+    const displayed = integer(projection.displayed, 'Investigation capsule Decision Fact displayed', 0, MAX_DECISION_FACT_PROJECTION_FACTS);
+    const omitted = integer(projection.omitted, 'Investigation capsule Decision Fact omitted', 0, MAX_DECISION_FACTS);
+    const contradictory = integer(projection.contradictory, 'Investigation capsule Decision Fact contradictory', 0, total);
+    const unresolved = integer(projection.unresolved, 'Investigation capsule Decision Fact unresolved', 0, total);
+    const facts = array(projection.facts, 'Investigation capsule Decision Facts', MAX_DECISION_FACT_PROJECTION_FACTS);
+    if (displayed > total || omitted !== total - displayed || facts.length !== displayed
+        || contradictory + unresolved > total)
+        fail('Investigation capsule Decision Fact projection');
+    const factIds = [];
+    let displayedContradictory = 0;
+    let displayedUnresolved = 0;
+    for (const [index, candidate] of facts.entries()) {
+        const validated = validateProjectedDecisionFact(candidate, `Investigation capsule Decision Fact ${index + 1}`);
+        factIds.push(validated.id);
+        if (validated.consistency === 'contradictory')
+            displayedContradictory += 1;
+        if (validated.consistency === 'unknown')
+            displayedUnresolved += 1;
+    }
+    validateSortedUnique(factIds, 'Investigation capsule Decision Facts');
+    if (contradictory < displayedContradictory || unresolved < displayedUnresolved
+        || (omitted === 0 && (contradictory !== displayedContradictory || unresolved !== displayedUnresolved))) {
+        fail('Investigation capsule Decision Fact state counts');
+    }
+    if (new TextEncoder().encode(JSON.stringify(projection)).byteLength > MAX_DECISION_FACT_PROJECTION_BYTES) {
+        fail('Investigation capsule Decision Fact projection byte limit');
+    }
+}
+function validateCurrentBrief(value) {
+    const brief = exact(value, ['schema', 'schemaVersion', 'generatedAt', 'target', 'targetType', 'task', 'taskLabel', 'question', 'summary', 'observation', 'decisionFacts', 'relationships', 'limitations'], 'Investigation capsule brief');
+    if (brief.schema !== LOOKUP_INVESTIGATION_BRIEF_SCHEMA
+        || brief.schemaVersion !== LOOKUP_INVESTIGATION_BRIEF_VERSION)
+        fail('Investigation capsule brief');
+    iso(brief.generatedAt, 'Investigation capsule brief generatedAt');
+    text(brief.target, 'Investigation capsule brief target', 253);
+    text(brief.targetType, 'Investigation capsule brief target type', 40);
+    enumeration(brief.task, ['general', 'acquisition', 'brand', 'incident', 'owned'], 'Investigation capsule brief task');
+    text(brief.taskLabel, 'Investigation capsule brief task label', 320);
+    text(brief.question, 'Investigation capsule brief question', 320);
+    text(brief.summary, 'Investigation capsule brief summary', 500);
+    const observation = exact(brief.observation, ['observedAt', 'evidenceAgeDays', 'completeSources', 'limitedSources', 'freshnessPolicy'], 'Investigation capsule observation');
+    iso(observation.observedAt, 'Investigation capsule observation time', true);
+    if (observation.evidenceAgeDays !== null)
+        integer(observation.evidenceAgeDays, 'Investigation capsule evidence age', 0, 1_000_000);
+    integer(observation.completeSources, 'Investigation capsule complete sources', 0, 100);
+    integer(observation.limitedSources, 'Investigation capsule limited sources', 0, 100);
+    const policy = exact(observation.freshnessPolicy, ['version', 'id', 'task', 'thresholdsDays'], 'Investigation capsule freshness policy');
+    if (policy.version !== 1)
+        fail('Investigation capsule freshness policy');
+    enumeration(policy.id, ['task-default', 'analyst-custom'], 'Investigation capsule freshness policy');
+    if (policy.task !== brief.task)
+        fail('Investigation capsule freshness policy');
+    const thresholds = exact(policy.thresholdsDays, ['registration', 'network', 'web'], 'Investigation capsule freshness thresholds');
+    for (const key of ['registration', 'network', 'web'])
+        integer(thresholds[key], 'Investigation capsule freshness threshold', 0, 3650);
+    validateDecisionFactProjection(brief.decisionFacts);
+    const relationships = exact(brief.relationships, ['nodes', 'edges', 'truncated', 'kinds'], 'Investigation capsule relationship summary');
+    integer(relationships.nodes, 'Investigation capsule relationship node count', 0, 72);
+    integer(relationships.edges, 'Investigation capsule relationship edge count', 0, 120);
+    boolean(relationships.truncated, 'Investigation capsule relationship truncation');
+    strings(relationships.kinds, 'Investigation capsule relationship kinds', 12, 320);
+    strings(brief.limitations, 'Investigation capsule brief limitations', 20, 320);
+    if (new TextEncoder().encode(JSON.stringify(brief)).byteLength > MAX_LOOKUP_INVESTIGATION_BRIEF_BYTES) {
+        fail('Investigation capsule brief byte limit');
+    }
+}
 function validateGraph(value) {
     const graph = exact(value, ['version', 'targetId', 'nodes', 'edges', 'sources', 'truncated', 'limitations'], 'Investigation capsule graph');
-    if (graph.version !== 2)
+    if (graph.version !== LOOKUP_ASSET_GRAPH_VERSION)
         fail('Investigation capsule graph');
     text(graph.targetId, 'Investigation capsule graph target', 160);
     const nodes = array(graph.nodes, 'Investigation capsule graph nodes', 72, 1);
@@ -1501,7 +2173,8 @@ function validateAnalystRecords(value) {
 }
 export function validateInvestigationCapsuleStructure(value) {
     const root = exact(value, ['schema', 'schemaVersion', 'generatedAt', 'application', 'target', 'sourceContracts', 'investigationBrief', 'graphSnapshot', 'analystRecords', 'integrity', 'limitations'], 'Investigation capsule');
-    if (root.schemaVersion !== LEGACY_INVESTIGATION_CAPSULE_VERSION && root.schemaVersion !== INVESTIGATION_CAPSULE_VERSION)
+    if (root.schemaVersion !== PUBLIC_INVESTIGATION_CAPSULE_VERSION
+        && root.schemaVersion !== INVESTIGATION_CAPSULE_VERSION)
         fail('Investigation capsule');
     iso(root.generatedAt, 'Investigation capsule generatedAt');
     const application = exact(root.application, ['name', 'version'], 'Investigation capsule application');
@@ -1527,21 +2200,27 @@ export function validateInvestigationCapsuleStructure(value) {
     const expectedContractIds = root.analystRecords === null
         ? ['lookup-evidence', 'investigation-brief', 'asset-graph']
         : ['lookup-evidence', 'investigation-brief', 'asset-graph', 'analyst-records'];
+    const expectedBriefVersion = root.schemaVersion === INVESTIGATION_CAPSULE_VERSION
+        ? LOOKUP_INVESTIGATION_BRIEF_VERSION
+        : PUBLIC_LOOKUP_INVESTIGATION_BRIEF_VERSION;
     if (!sameValues(contracts.map((candidate) => candidate.id), expectedContractIds))
         fail('Investigation capsule source contracts');
     if (!byId.has('lookup-evidence') || !byId.has('investigation-brief') || !byId.has('asset-graph')
         || byId.get('lookup-evidence')?.embedded !== false
         || byId.get('investigation-brief')?.schema !== LOOKUP_INVESTIGATION_BRIEF_SCHEMA
-        || byId.get('investigation-brief')?.version !== 1
+        || byId.get('investigation-brief')?.version !== expectedBriefVersion
         || byId.get('investigation-brief')?.embedded !== true
-        || byId.get('asset-graph')?.schema !== 'whoisleuth.lookup-asset-graph'
-        || byId.get('asset-graph')?.version !== 2
+        || byId.get('asset-graph')?.schema !== LOOKUP_ASSET_GRAPH_SCHEMA
+        || byId.get('asset-graph')?.version !== LOOKUP_ASSET_GRAPH_VERSION
         || byId.get('asset-graph')?.embedded !== true
-        || (byId.has('analyst-records') && (byId.get('analyst-records')?.schema !== 'whoisleuth.case-analyst-records'
-            || byId.get('analyst-records')?.version !== 1
+        || (byId.has('analyst-records') && (byId.get('analyst-records')?.schema !== INVESTIGATION_CAPSULE_ANALYST_RECORDS_SCHEMA
+            || byId.get('analyst-records')?.version !== INVESTIGATION_CAPSULE_ANALYST_RECORDS_VERSION
             || byId.get('analyst-records')?.embedded !== true)))
         fail('Investigation capsule source contracts');
-    validateBrief(root.investigationBrief);
+    if (root.schemaVersion === INVESTIGATION_CAPSULE_VERSION)
+        validateCurrentBrief(root.investigationBrief);
+    else
+        validatePublicBrief(root.investigationBrief);
     validateGraph(root.graphSnapshot);
     validateAnalystRecords(root.analystRecords);
     const brief = root.investigationBrief;
@@ -1551,17 +2230,12 @@ export function validateInvestigationCapsuleStructure(value) {
         || brief.relationships.nodes !== graph.nodes.length
         || brief.relationships.edges !== graph.edges.length)
         fail('Investigation capsule projection linkage');
-    const current = root.schemaVersion === INVESTIGATION_CAPSULE_VERSION;
-    const integrity = exact(root.integrity, current
-        ? ['algorithm', 'canonicalization', 'scope', 'briefDigest', 'graphDigest', 'analystRecordsDigest', 'digestSha256']
-        : ['algorithm', 'briefDigest', 'graphDigest', 'analystRecordsDigest'], 'Investigation capsule integrity');
+    const integrity = exact(root.integrity, ['algorithm', 'canonicalization', 'scope', 'briefDigest', 'graphDigest', 'analystRecordsDigest', 'digestSha256'], 'Investigation capsule integrity');
     if (integrity.algorithm !== 'SHA-256')
         fail('Investigation capsule integrity');
-    if (current) {
-        if (integrity.canonicalization !== 'sorted-json-v2' || integrity.scope !== 'capsule excluding integrity')
-            fail('Investigation capsule integrity');
-        digest(integrity.digestSha256, 'Investigation capsule digest');
-    }
+    if (integrity.canonicalization !== 'sorted-json-v2' || integrity.scope !== 'capsule excluding integrity')
+        fail('Investigation capsule integrity');
+    digest(integrity.digestSha256, 'Investigation capsule digest');
     digest(integrity.briefDigest, 'Investigation capsule brief digest');
     digest(integrity.graphDigest, 'Investigation capsule graph digest');
     if (integrity.analystRecordsDigest !== null)
@@ -1791,7 +2465,7 @@ function validateDomainChangePacket(value) {
     }))
         fail('Domain change packet summary');
     strings(root.limitations, 'Domain change packet limitations', 8, 600);
-    validateIntegrity(root.integrity, 'Domain change packet integrity', root.version, 1, DOMAIN_CHANGE_PACKET_VERSION);
+    validateIntegrity(root.integrity, 'Domain change packet integrity', root.version, DOMAIN_CHANGE_PACKET_VERSION);
 }
 export function validateSignedDigestArtifactStructure(schema, value) {
     if (value.schema !== schema)
@@ -1808,7 +2482,7 @@ export function validateSignedDigestArtifactStructure(schema, value) {
         validateBulkReviewManifest(value);
     else if (schema === DOMAIN_CONTROL_MANIFEST_SCHEMA) {
         try {
-            normalizeDomainControlPassportDocument(value);
+            normalizeDomainControlManifestDocument(value);
         }
         catch {
             fail('Domain control manifest');