@slicedearth/whoisleuth-cli 2.4.0 → 2.6.0

package/packages/cases/case-report.mjs

@@ -8,14 +8,22 @@
 // contains raw RDAP/WHOIS material. This module deliberately excludes all raw
 // registry/web responses, contacts, cookies, screenshots, and authentication
 // data. Reports contain only the normalized case record.
-import { caseEvidenceTimeline, compareCaseEvidence, currentCaseEvidence } from "./case-model.mjs";
+import { caseEvidenceTimeline, compareCaseEvidence, currentCaseEvidence, publishedCaseEvidenceTimelineForVerification } from "./case-evidence-model.mjs";
 import { httpSecurityHeaderLabel } from "./http-summary.mjs";
-import { analystInteroperabilityTags } from "../../lib/analyst-taxonomy.mjs";
-import { buildPortableGeneratorMetadata, portableGeneratorAttribution, } from "../../lib/portable-generator.mjs";
+import { webCollectionScoreLimitation } from "../evidence/collection-quality.mjs";
+import { analystInteroperabilityTags } from "../analysis/analyst-taxonomy.mjs";
+import { caseEvidenceLinkIssues } from "./case-evidence-links.mjs";
+import { caseTypeSummary } from "./case-workflow-metadata.mjs";
+import { caseClosureHistoryQualification } from "./case-response-outcomes.mjs";
+import { buildPortableGeneratorMetadata, portableGeneratorAttribution, } from "../analysis/portable-generator.mjs";
 import { buildCaseResponseLifecycleSummary, CASE_EVIDENCE_RELATION_STANCES } from "./case-response-model.mjs";
 import { normalizeCaseBrandProfileIds } from "./case-brand-profile-references.mjs";
+import { EVIDENCE_FOLLOW_UP_CASE_REPORT_SCHEMA_VERSION } from "../contracts/case-portability.mjs";
+import { OBJECT_RESPONSE_CASE_REPORT_SCHEMA_VERSION } from "../contracts/case-portability.mjs";
+import { CASE_DELIVERY_RECEIPT_LIMITATION } from "./case-packet-correction.mjs";
 import { CASE_RECHECK_CONDITIONS } from "./case-recheck-model.mjs";
-import { CASE_REPORT_SCHEMA, CASE_REPORT_SCHEMA_VERSION, PUBLISHED_V2_3_CASE_REPORT_SCHEMA_VERSION, } from "../contracts/case-portability.mjs";
+import { escapeCaseMarkdownInline as escapeMarkdownInline } from "./case-markdown.mjs";
+import { CASE_REPORT_SCHEMA, CASE_REPORT_SCHEMA_VERSION, LATEST_PUBLIC_CASE_REPORT_SCHEMA_VERSION, PUBLISHED_V2_3_CASE_REPORT_SCHEMA_VERSION, } from "../contracts/case-portability.mjs";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -35,16 +43,6 @@ const LIMITATIONS_TEXT = [
     'Snapshot hostnames are excluded; supporting DNS, TLS and web observations need not concern the Case registration domain.',
     ...PUBLISHED_V2_3_LIMITATIONS.slice(2),
 ].join(' ');
-function escapeMarkdownInline(text) {
-    return String(text)
-        .replace(/[\r\n\u2028\u2029]+/g, ' ')
-        .replace(/([\\`*_{}\[\]<>()#+!|~])/g, '\\$1')
-        // GFM autolinks bare URLs independently of ordinary link syntax. Break
-        // the scheme or the first `www.` separator without making normal domains,
-        // dates, and prose noisy in the report source.
-        .replace(/\b([a-z][a-z0-9+.-]{1,31}):(?=\/\/)/gi, '$1\\:')
-        .replace(/\bwww\.(?=\S)/gi, 'www\\.');
-}
 /**
  * Escapes a multiline note body for safe inclusion in a Markdown blockquote.
  * Each line is individually escaped and prefixed with `> `.
@@ -90,6 +88,12 @@ function formatReportValue(value, field) {
         return String(value);
     return String(value);
 }
+function readableRiskScore(snapshot) {
+    const value = escapeMarkdownInline(formatReportValue(snapshot.riskScore));
+    const limitation = snapshot.riskScore === null ? null
+        : webCollectionScoreLimitation(snapshot.webCollectionQuality, snapshot.scanDepth);
+    return limitation ? `${value} — ${escapeMarkdownInline(limitation)}` : value;
+}
 /**
  * Returns a shallow clone of a snapshot containing only known schema fields.
  * Unknown/imported keys are never included.
@@ -111,6 +115,7 @@ function pickKnownSnapshotFields(snapshot) {
         capturedAt: snapshot.capturedAt,
         source: snapshot.source,
         scanDepth: snapshot.scanDepth,
+        ...(snapshot.webCollectionQuality ? { webCollectionQuality: { ...snapshot.webCollectionQuality } } : {}),
         availability: snapshot.availability,
         confidence: snapshot.confidence,
         riskModelVersion: snapshot.riskModelVersion,
@@ -144,6 +149,7 @@ function pickKnownSnapshotFields(snapshot) {
         reusesOfficialAssets: snapshot.reusesOfficialAssets,
         hasPasswordField: snapshot.hasPasswordField,
         hasExternalFormAction: snapshot.hasExternalFormAction,
+        ...(snapshot.hasExternalPasswordForm === undefined ? {} : { hasExternalPasswordForm: snapshot.hasExternalPasswordForm }),
         phishingLanguageMatch: snapshot.phishingLanguageMatch,
         privacyProtected: snapshot.privacyProtected ?? null,
         idnReferenceMatch: snapshot.idnReferenceMatch ?? null,
@@ -173,14 +179,7 @@ export function buildCaseReport(caseRecord, options = {}) {
     const generator = buildPortableGeneratorMetadata(options.applicationVersion);
     // --- Build JSON report ---
     const timeline = caseEvidenceTimeline(caseRecord.evidenceHistory);
-    const timelineEntries = timeline.map((entry) => ({
-        snapshot: pickKnownSnapshotFields(entry.snapshot),
-        isBaseline: entry.isBaseline,
-        hasRepeatedObservation: entry.hasRepeatedObservation,
-        changes: entry.changes?.map(({ field, label, before, after, tone }) => ({ field, label, before, after, tone })) ?? null,
-        hasIncomparableChange: entry.hasIncomparableChange,
-        incomparableReasons: [...entry.incomparableReasons],
-    }));
+    const timelineEntries = projectReportTimeline(timeline);
     const selection = currentCaseEvidence(caseRecord);
     const latest = selection.snapshot;
     const currentAssessment = latest ? pickKnownSnapshotFields(latest) : null;
@@ -221,7 +220,9 @@ export function buildCaseReport(caseRecord, options = {}) {
         currentAssessment,
         evidenceTimeline: timelineEntries,
         analystResponse: {
+            ...(caseRecord.workflowMetadata === undefined ? {} : { workflowMetadata: structuredClone(caseRecord.workflowMetadata) }),
             evidencePins: caseRecord.evidencePins.map((item) => ({ ...item, limitations: [...item.limitations] })),
+            ...(caseRecord.evidenceLinks === undefined ? {} : { evidenceLinks: structuredClone(caseRecord.evidenceLinks) }),
             decisions: caseRecord.decisions.map((item) => ({ ...item, evidencePinIds: [...item.evidencePinIds] })),
             actions: caseRecord.actions.map((item) => ({
                 ...item,
@@ -270,11 +271,29 @@ export function buildCaseReport(caseRecord, options = {}) {
     const md = buildMarkdown(json, options.includeAttribution !== false);
     return { json, markdown: md };
 }
+function projectReportTimeline(timeline) {
+    return timeline.map(entry => ({
+        snapshot: pickKnownSnapshotFields(entry.snapshot), isBaseline: entry.isBaseline,
+        hasRepeatedObservation: entry.hasRepeatedObservation,
+        changes: entry.changes?.map(({ field, label, before, after, tone }) => ({ field, label, before, after, tone })) ?? null,
+        hasIncomparableChange: entry.hasIncomparableChange, incomparableReasons: [...entry.incomparableReasons],
+    }));
+}
 /** Expected strict reader projection; historical disclosure wording is immutable. */
 export function buildCaseReportVerificationProjection(caseRecord, options, schemaVersion) {
-    const current = buildCaseReport(caseRecord, options).json;
+    const generated = buildCaseReport(caseRecord, options).json;
     if (schemaVersion === CASE_REPORT_SCHEMA_VERSION)
-        return current;
+        return generated;
+    if (schemaVersion === OBJECT_RESPONSE_CASE_REPORT_SCHEMA_VERSION)
+        return { ...generated, schemaVersion };
+    if (schemaVersion === EVIDENCE_FOLLOW_UP_CASE_REPORT_SCHEMA_VERSION)
+        return { ...generated, schemaVersion };
+    if (caseRecord.evidenceHistory.some(snapshot => snapshot.webCollectionQuality !== undefined)) {
+        throw new TypeError('Published report formats cannot declare newer collection-quality fields.');
+    }
+    const current = { ...generated, evidenceTimeline: projectReportTimeline(publishedCaseEvidenceTimelineForVerification(caseRecord.evidenceHistory)) };
+    if (schemaVersion === LATEST_PUBLIC_CASE_REPORT_SCHEMA_VERSION)
+        return { ...current, schemaVersion };
     if (schemaVersion !== PUBLISHED_V2_3_CASE_REPORT_SCHEMA_VERSION) {
         throw new TypeError('No strict Case report projection is defined for this version.');
     }
@@ -325,6 +344,17 @@ function buildMarkdown(report, includeAttribution) {
     if (report.case.tags.length > 0) {
         lines.push(`| Tags | ${escapeMarkdownInline(report.case.tags.join(', '))} |`);
     }
+    const caseTypes = caseTypeSummary(report.analystResponse.workflowMetadata ? { workflowMetadata: report.analystResponse.workflowMetadata } : {});
+    if (caseTypes)
+        lines.push(`| Case types | ${escapeMarkdownInline(caseTypes)} |`);
+    const context = report.analystResponse.workflowMetadata?.investigationContext;
+    if (context) {
+        lines.push(`| Investigation objective | ${escapeMarkdownInline(context.objective)} |`);
+        lines.push(`| Incident URL (${context.urlRetention === 'exact' ? 'exact' : 'origin only'}) | ${escapeMarkdownInline(context.incidentUrl)} |`);
+    }
+    for (const target of report.analystResponse.workflowMetadata?.incidentTargets ?? []) {
+        lines.push(`| Incident link (${target.state}) | ${escapeMarkdownInline(target.url)} |`);
+    }
     lines.push(`| Notes included | ${report.case.notesIncluded ? 'Yes' : 'No'} |`);
     lines.push('');
     // Current assessment
@@ -333,7 +363,7 @@ function buildMarkdown(report, includeAttribution) {
     if (report.currentAssessment) {
         const a = report.currentAssessment;
         lines.push(`- **Availability:** ${escapeMarkdownInline(formatReportValue(a.availability))}`);
-        lines.push(`- **Risk score:** ${escapeMarkdownInline(formatReportValue(a.riskScore))}`);
+        lines.push(`- **Risk score:** ${readableRiskScore(a)}`);
         lines.push(`- **Risk model:** ${a.riskModelVersion === null ? 'Unversioned' : `v${escapeMarkdownInline(formatReportValue(a.riskModelVersion))}`}`);
         lines.push(`- **Brand Profile context:** ${escapeMarkdownInline(formatReportValue(a.profileContextState))}`);
         if (a.profileContextLimitation)
@@ -388,7 +418,7 @@ function buildMarkdown(report, includeAttribution) {
             lines.push('**Key evidence:**');
             lines.push('');
             lines.push(`- Availability: ${escapeMarkdownInline(formatReportValue(snap.availability))}`);
-            lines.push(`- Risk score: ${escapeMarkdownInline(formatReportValue(snap.riskScore))}`);
+            lines.push(`- Risk score: ${readableRiskScore(snap)}`);
             lines.push(`- Risk model: ${snap.riskModelVersion === null ? 'Unversioned' : `v${escapeMarkdownInline(formatReportValue(snap.riskModelVersion))}`}`);
             lines.push(`- Brand Profile context: ${escapeMarkdownInline(formatReportValue(snap.profileContextState))}`);
             if (snap.profileContextLimitation)
@@ -455,6 +485,8 @@ function buildMarkdown(report, includeAttribution) {
                     lines.push('> Opportunity scores and factors use different or unversioned models, so their numeric difference is not treated as a domain change.');
                 if (reasons.includes('scan-depth'))
                     lines.push('> Capture depths differ, so unevaluated deep signals are not treated as additions or removals.');
+                if (reasons.includes('collection-quality'))
+                    lines.push('> Missing or incomplete observations prevent comparison of affected registration, page, favicon or score fields.');
                 if (reasons.length === 0 || reasons.includes('other'))
                     lines.push('> The observations differ materially, but no reliable field-level comparison is available.');
                 lines.push('');
@@ -464,7 +496,7 @@ function buildMarkdown(report, includeAttribution) {
     lines.push('## Analyst Decision Packet');
     lines.push('');
     const response = report.analystResponse;
-    if (!response.evidencePins.length && !response.sightings.length && !response.decisions.length && !response.actions.length && !response.assertions.length && !response.manualTrail.length && !response.observedEffects.reviews.length && !response.closures.records.length && !response.branches.length) {
+    if (!response.evidencePins.length && !response.evidenceLinks?.length && !response.sightings.length && !response.decisions.length && !response.actions.length && !response.assertions.length && !response.manualTrail.length && !response.observedEffects.reviews.length && !response.closures.records.length && !response.branches.length) {
         lines.push('No evidence pins, source-qualified sightings, structured assertions, decision records, response actions, independent effect reviews, closures, or manual investigation steps recorded.');
         lines.push('');
     }
@@ -476,6 +508,8 @@ function buildMarkdown(report, includeAttribution) {
         for (const pin of response.evidencePins) {
             lines.push(`- **${escapeMarkdownInline(pin.label)}:** ${escapeMarkdownInline(pin.value)}`);
             lines.push(`  Source: ${escapeMarkdownInline(pin.source)}; observed ${escapeMarkdownInline(pin.observedAt ?? 'Time unavailable')}; completeness ${escapeMarkdownInline(pin.completeness)}.`);
+            if (pin.responseObject)
+                lines.push(`  Exact object: ${escapeMarkdownInline(pin.responseObject.kind)} · ${escapeMarkdownInline(pin.responseObject.identifier)}`);
             if (pin.limitations.length)
                 lines.push(`  Limitations: ${escapeMarkdownInline(pin.limitations.join('; '))}`);
         }
@@ -539,6 +573,12 @@ function buildMarkdown(report, includeAttribution) {
             }
             lines.push('');
         }
+        if (response.evidenceLinks?.length) {
+            lines.push('### Analyst-declared evidence relationships', '');
+            for (const { link, missingPinIds, cyclic } of caseEvidenceLinkIssues(response.evidenceLinks, response.evidencePins))
+                lines.push(`- ${escapeMarkdownInline(link.fromPinId)} ${link.kind === 'derived_from' ? 'derived from' : 'shares a source with'} ${escapeMarkdownInline(link.toPinId)} · recorded ${link.createdAt}`, `  Basis: ${escapeMarkdownInline(link.basis)}`, ...(link.withdrawal ? [`  Withdrawn ${link.withdrawal.at}: ${escapeMarkdownInline(link.withdrawal.reason)}`] : []), ...(missingPinIds.length ? [`  Referenced pins not retained: ${missingPinIds.map(escapeMarkdownInline).join(', ')}`] : []), ...(cyclic ? ['  Conflicting imported derivation cycle; no order is inferred.'] : []));
+            lines.push('These relationships record analyst attribution, not independent corroboration or added confidence.', '');
+        }
         lines.push('### Decisions');
         lines.push('');
         if (!response.decisions.length)
@@ -558,12 +598,22 @@ function buildMarkdown(report, includeAttribution) {
         for (const action of response.actions) {
             lines.push(`- **${escapeMarkdownInline(action.type.replaceAll('_', ' '))}:** ${escapeMarkdownInline(action.recipient)} (${escapeMarkdownInline(action.state)})`);
             lines.push(`  Contact source: ${escapeMarkdownInline(action.contactSource)}; updated ${escapeMarkdownInline(action.updatedAt)}.`);
+            lines.push(`  Object binding: ${action.responseObjects?.length ? action.responseObjects.map(object => `${escapeMarkdownInline(object.kind)} · ${escapeMarkdownInline(object.identifier)}`).join('; ') : 'Unknown; historical or unbound actions do not establish exact-object coverage.'}`);
             if (action.routeObservedAt)
                 lines.push(`  Route reviewed: ${escapeMarkdownInline(action.routeObservedAt)}`);
             if (action.routeReviewAfter)
                 lines.push(`  Route review due: ${escapeMarkdownInline(action.routeReviewAfter)}`);
             if (action.originActionId)
                 lines.push(`  Originating action: ${escapeMarkdownInline(action.originActionId)}`);
+            if (action.amendment)
+                lines.push(`  Amendment of submitted packet SHA-256: ${action.amendment.packetDigestSha256}; request events: ${action.amendment.requestEventIds.map(escapeMarkdownInline).join(', ')}`);
+            if (action.correction)
+                lines.push(`  ${action.correction.purpose === 'correction' ? 'Correction request' : 'Retraction request'} for delivery event ${escapeMarkdownInline(action.correction.deliveryEventId)}; packet v${action.correction.packetVersion} SHA-256: ${action.correction.packetDigestSha256}`, `  Reason: ${escapeMarkdownInline(action.correction.reason)}`, `  Previous statement: ${escapeMarkdownInline(action.correction.previousStatement)}`, `  Corrected statement: ${escapeMarkdownInline(action.correction.correctedStatement || 'Request to retract the previous statement')}`, `  Corrected evidence pins: ${action.correction.evidencePinIds.map(escapeMarkdownInline).join(', ')}`, '  Preparation is not delivery, recipient acceptance, restoration or independent recheck.');
+            for (const event of action.history)
+                if (event.evidenceRequest) {
+                    const request = event.evidenceRequest;
+                    lines.push(`  Requested evidence [${request.state}]: ${escapeMarkdownInline(request.summary)}; deadline: ${request.dueAt ?? 'not stated'}; original packet: ${request.packetDigestSha256}${event.applied ? '' : ' (retained conflict)'}`, `  Prepared pins: ${request.evidencePinIds.map(escapeMarkdownInline).join(', ') || 'none'}${request.rationale ? `; ${escapeMarkdownInline(request.rationale)}` : ''}`);
+                }
             if (action.dueAt)
                 lines.push(`  Due: ${escapeMarkdownInline(action.dueAt)}`);
             if (action.followUpAt)
@@ -580,8 +630,14 @@ function buildMarkdown(report, includeAttribution) {
                 lines.push(`  - ${escapeMarkdownInline(event.occurredAt)} · ${escapeMarkdownInline(event.previousState ?? 'none')} → ${escapeMarkdownInline(event.nextState)} · ${escapeMarkdownInline(event.sourceClass)} · ${event.applied ? 'applied' : 'retained conflict'}`);
                 if (event.providerOutcome)
                     lines.push(`    Provider outcome at this time: ${escapeMarkdownInline(event.providerOutcome.replaceAll('_', ' '))}`);
+                if (event.responseObjects?.length)
+                    lines.push(`    Objects at this event: ${event.responseObjects.map(object => `${escapeMarkdownInline(object.kind)} · ${escapeMarkdownInline(object.identifier)}`).join('; ')}`);
+                if (event.objectOutcome)
+                    lines.push(`    Source-reported object outcome: ${escapeMarkdownInline(event.objectOutcome)}; not independent verification or causation.`);
                 if (event.reference)
                     lines.push(`    Event reference: ${escapeMarkdownInline(event.reference)}`);
+                if (event.packetReceipt)
+                    lines.push(`    Retained packet v${event.packetReceipt.packetVersion}: ${event.packetReceipt.packetDigestSha256}; recipient ${escapeMarkdownInline(event.packetReceipt.recipient)}; audience ${escapeMarkdownInline(event.packetReceipt.profile)}; generated ${event.packetReceipt.packetGeneratedAt}`, `    ${CASE_DELIVERY_RECEIPT_LIMITATION}`);
                 if (event.evidencePinId)
                     lines.push(`    Evidence pin: ${escapeMarkdownInline(event.evidencePinId)}`);
                 if (event.limitations.length)
@@ -631,6 +687,10 @@ function buildMarkdown(report, includeAttribution) {
         lines.push('- No independent observed-effect review recorded.');
     for (const review of response.observedEffects.reviews) {
         lines.push(`- **${escapeMarkdownInline(review.state.replaceAll('_', ' '))}** (${escapeMarkdownInline(review.observedAt)}): ${escapeMarkdownInline(review.source)}; class ${escapeMarkdownInline(review.sourceClass)}; completeness ${escapeMarkdownInline(review.completeness)}.`);
+        if (review.responseObject)
+            lines.push(`  Exact object: ${escapeMarkdownInline(review.responseObject.kind)} · ${escapeMarkdownInline(review.responseObject.identifier)}`);
+        if (review.objectOutcome)
+            lines.push(`  Independently recorded object outcome: ${escapeMarkdownInline(review.objectOutcome)}; point-in-time observation, not report causation or recurrence.`);
         if (review.recheck) {
             lines.push(`  Question ${escapeMarkdownInline(review.recheck.questionId)}: ${escapeMarkdownInline(review.recheck.question)}`);
             lines.push(`  Recheck target: ${escapeMarkdownInline(review.recheck.targetHostname)}; retained comparison conditions: ${escapeMarkdownInline(review.recheck.conditions)}`);
@@ -653,13 +713,19 @@ function buildMarkdown(report, includeAttribution) {
         lines.push('- No deliberate analyst closure recorded.');
     for (const closure of response.closures.records) {
         lines.push(`- **Closure · ${escapeMarkdownInline(closure.reason.replaceAll('_', ' '))}** (${escapeMarkdownInline(closure.createdAt)}): ${escapeMarkdownInline(closure.summary)}`);
+        lines.push(`  Scope: ${closure.responseObject ? `${escapeMarkdownInline(closure.responseObject.kind)} · ${escapeMarkdownInline(closure.responseObject.identifier)}; other objects and the Case remain independent.` : 'Whole Case analyst decision.'}`);
         if (closure.observedEffectReviewId)
             lines.push(`  Independent review: ${escapeMarkdownInline(closure.observedEffectReviewId)}`);
         if (closure.actionId)
             lines.push(`  Provider action: ${escapeMarkdownInline(closure.actionId)}`);
+        const qualification = caseClosureHistoryQualification(closure, response.actions);
+        if (qualification)
+            lines.push(`  History qualification: ${escapeMarkdownInline(qualification)}`);
         if (closure.limitations.length)
             lines.push(`  Limitations: ${escapeMarkdownInline(closure.limitations.join('; '))}`);
     }
+    if (response.closures.omitted)
+        lines.push(`- Closure records not retained: ${response.closures.omitted}. ${escapeMarkdownInline(response.closures.limitations.join('; '))}`);
     lines.push('');
     // Analyst notes (only when included)
     if (report.case.notesIncluded && Array.isArray(report.case.notes) && report.case.notes.length > 0) {

package/packages/cases/case-requested-evidence.mjs

@@ -0,0 +1,146 @@
+import { array, enumeration, exact, HEX_DIGEST_RE, iso, text } from "../evidence/artifact-structure.mjs";
+import { assertWorkspaceInputGraph } from "../workspace/hostile-input.mjs";
+import { MAX_DECISION_PIN_REFERENCES, MAX_RESPONSE_RATIONALE_LENGTH, MAX_RESPONSE_VALUE_LENGTH } from "../contracts/case-portability.mjs";
+import { SAFE_ID_RE } from "./case-response-values.mjs";
+function identifier(value, label) {
+    const result = text(value, label, 64);
+    if (!SAFE_ID_RE.test(result))
+        throw new TypeError(`${label} is invalid.`);
+    return result;
+}
+function identifiers(value, label) {
+    const result = array(value, label, MAX_DECISION_PIN_REFERENCES).map(item => identifier(item, label));
+    if (new Set(result).size !== result.length)
+        throw new TypeError(`${label} contains duplicate identities.`);
+    return result;
+}
+function packetDigest(value) {
+    if (typeof value !== 'string' || !HEX_DIGEST_RE.test(value))
+        throw new TypeError('Select a recorded submitted-packet digest.');
+    return value;
+}
+export function readCaseEvidenceRequest(raw) {
+    if (raw === undefined)
+        return undefined;
+    assertWorkspaceInputGraph(raw, 'Requested evidence');
+    const row = exact(raw, ['id', 'packetDigestSha256', 'summary', 'dueAt', 'state', 'evidencePinIds', 'rationale', 'previousEventIds'], 'Requested evidence');
+    iso(row.dueAt, 'Requested evidence deadline', true);
+    const summary = text(row.summary, 'Requested evidence summary', MAX_RESPONSE_VALUE_LENGTH).trim();
+    const rationale = text(row.rationale, 'Requested evidence rationale', MAX_RESPONSE_RATIONALE_LENGTH, true).trim();
+    const state = enumeration(row.state, ['requested', 'prepared', 'unavailable'], 'Requested evidence state');
+    const evidencePinIds = identifiers(row.evidencePinIds, 'Requested evidence pins');
+    if (!summary || (state === 'prepared' && !evidencePinIds.length) || (state === 'unavailable' && !rationale)) {
+        throw new TypeError('Prepared evidence needs retained pins; unavailable evidence needs an explanation.');
+    }
+    return { id: identifier(row.id, 'Evidence request identity'), packetDigestSha256: packetDigest(row.packetDigestSha256),
+        summary, dueAt: row.dueAt, state, evidencePinIds, rationale,
+        previousEventIds: identifiers(row.previousEventIds, 'Prior evidence request events') };
+}
+export function readCasePacketAmendment(raw) {
+    if (raw === undefined)
+        return undefined;
+    assertWorkspaceInputGraph(raw, 'Packet amendment');
+    const row = exact(raw, ['packetDigestSha256', 'requestEventIds'], 'Packet amendment');
+    const requestEventIds = identifiers(row.requestEventIds, 'Amendment request events');
+    if (!requestEventIds.length)
+        throw new TypeError('Select at least one prepared evidence request.');
+    return { packetDigestSha256: packetDigest(row.packetDigestSha256), requestEventIds };
+}
+export function assertEvidenceRequestEvent(request, event) {
+    if (request && (event.nextState !== 'acknowledged' || !['submitted', 'acknowledged'].includes(String(event.previousState))
+        || (request.state === 'requested'
+            ? event.sourceClass !== 'provider' || event.providerOutcome !== 'more_information_requested' || request.evidencePinIds.length > 0 || Boolean(request.rationale) || request.previousEventIds.length > 0
+            : event.sourceClass !== 'analyst' || request.previousEventIds.length === 0)))
+        throw new TypeError('Requested evidence has incompatible event provenance.');
+}
+/** A digest belongs to the explicit delivery event, never the latest mutable reference. */
+export function submittedPacketReceipts(action) {
+    return action.history.flatMap(event => {
+        const match = /^response-packet-sha256:([a-f0-9]{64})$/u.exec(event.reference ?? '');
+        return event.applied && ['authorised', 'submitted'].includes(event.previousState ?? '') && event.nextState === 'submitted'
+            && event.sourceClass === 'analyst' && match
+            ? [{ eventId: event.id, digestSha256: match[1], occurredAt: event.occurredAt }] : [];
+    });
+}
+export function latestEvidenceRequests(action) {
+    const events = action.history.filter((event) => event.applied && Boolean(event.evidenceRequest));
+    const replaced = new Set(events.flatMap(event => event.evidenceRequest.previousEventIds
+        .filter(id => events.some(parent => parent.id === id && parent.evidenceRequest.id === event.evidenceRequest.id))));
+    return events.filter(event => !replaced.has(event.id));
+}
+/** Causal links order same-time reviews and retain concurrent branches for explicit reconciliation. */
+export function assertEvidenceRequestHistory(events, missingHistory) {
+    const byId = new Map(events.map(event => [event.id, event]));
+    const complete = new Set(), visiting = new Set();
+    const visit = (id) => {
+        if (complete.has(id))
+            return;
+        if (visiting.has(id))
+            throw new TypeError('Requested evidence history contains a cycle.');
+        visiting.add(id);
+        const request = byId.get(id)?.evidenceRequest;
+        for (const parentId of request?.previousEventIds ?? []) {
+            const parent = byId.get(parentId);
+            if (!parent && missingHistory)
+                continue;
+            if (!parent?.evidenceRequest || parent.evidenceRequest.id !== request.id
+                || parent.evidenceRequest.summary !== request.summary || parent.evidenceRequest.dueAt !== request.dueAt
+                || parent.evidenceRequest.packetDigestSha256 !== request.packetDigestSha256)
+                throw new TypeError('Requested evidence history does not preserve its original request.');
+            visit(parentId);
+        }
+        visiting.delete(id);
+        complete.add(id);
+    };
+    for (const event of events)
+        visit(event.id);
+}
+export function assertEvidenceRequestTransition(action, request, sourceClass, providerOutcome, validPinIds) {
+    if (!['submitted', 'acknowledged'].includes(action.state)
+        || !submittedPacketReceipts(action).some(receipt => receipt.digestSha256 === request.packetDigestSha256)) {
+        throw new Error('Requested evidence must refer to an explicitly recorded packet delivery on an open action.');
+    }
+    const previousEvents = latestEvidenceRequests(action).filter(event => event.evidenceRequest.id === request.id);
+    if (!previousEvents.length) {
+        if (request.state !== 'requested' || sourceClass !== 'provider' || providerOutcome !== 'more_information_requested'
+            || request.evidencePinIds.length || request.rationale || request.previousEventIds.length)
+            throw new Error('A new evidence request must record the provider request before preparation.');
+    }
+    else if (sourceClass !== 'analyst' || request.state === 'requested'
+        || previousEvents.some(({ evidenceRequest: previous }) => request.summary !== previous.summary
+            || request.dueAt !== previous.dueAt || request.packetDigestSha256 !== previous.packetDigestSha256)) {
+        throw new Error('Keep the original provider request unchanged; append a separate request for changed requirements.');
+    }
+    if (JSON.stringify(request.previousEventIds.slice().sort()) !== JSON.stringify(previousEvents.map(event => event.id).sort())) {
+        throw new Error('The evidence preparation changed. Review all current request events before saving.');
+    }
+    if (validPinIds && request.evidencePinIds.some(id => !validPinIds.has(id)))
+        throw new Error('Requested evidence refers to a pin no longer retained in this Case.');
+}
+export function assertPacketAmendment(actions, originActionId, amendment) {
+    const original = actions.find(action => action.id === originActionId);
+    if (!original || !submittedPacketReceipts(original).some(receipt => receipt.digestSha256 === amendment.packetDigestSha256)) {
+        throw new Error('An amendment requires the exact recorded packet delivery from its originating action.');
+    }
+    const latest = latestEvidenceRequests(original);
+    if (amendment.requestEventIds.some(id => !latest.some(event => event.id === id
+        && latest.filter(other => other.evidenceRequest.id === event.evidenceRequest.id).length === 1
+        && event.evidenceRequest.state === 'prepared' && event.evidenceRequest.packetDigestSha256 === amendment.packetDigestSha256))) {
+        throw new Error('Review the current prepared evidence requests before creating or submitting an amendment.');
+    }
+}
+export function assertPacketAmendmentSelection(actions, selectedActionId, selectedPinIds) {
+    const action = actions.find(item => item.id === selectedActionId);
+    if (!action?.amendment)
+        return;
+    assertPacketAmendment(actions, action.originActionId, action.amendment);
+    const original = actions.find(item => item.id === action.originActionId);
+    const required = latestEvidenceRequests(original).filter(event => action.amendment.requestEventIds.includes(event.id))
+        .flatMap(event => event.evidenceRequest.evidencePinIds);
+    if (required.some(id => !selectedPinIds.has(id)))
+        throw new TypeError('Select every prepared request pin for this amendment; the original packet is not regenerated.');
+}
+export function evidenceRequestDelivery(actions, actionId, eventId) {
+    return actions.flatMap(action => action.originActionId === actionId && action.amendment?.requestEventIds.includes(eventId)
+        ? submittedPacketReceipts(action).map(receipt => ({ actionId: action.id, ...receipt })) : []);
+}