@slicedearth/whoisleuth-cli 2.4.0 → 2.6.0

package/packages/cases/case-record-operations.mjs

@@ -1,13 +1,18 @@
 // Pure, framework-neutral analyst-case records, evidence histories, bounded
 // record normalization, and analyst updates.
-import { canonicalRegistrableDomain } from "../../lib/registrable-domain.mjs";
-import { parseCredentialFreeHttpUrl } from "../evidence/lookup-target.mjs";
+import { normalizeCaseObjective, parseIncidentUrlContext, } from "./case-incident-context.mjs";
 import { selectExistingCase } from "./case-selection.mjs";
+import { emptyCaseWorkflowMetadata, updateCaseWorkflowMetadata } from "./case-workflow-metadata.mjs";
+import { assertCaseResponseObject, readCaseResponseObject, readCaseResponseObjects, sameCaseResponseObject } from "./case-response-object.mjs";
+import { correctionDelivery, readCasePacketCorrection, readCaseDeliveryPacketReceipt } from "./case-packet-correction.mjs";
+import { readCaseWorkflowFields } from "./case-workflow-migration.mjs";
 import { appendCaseAction, appendCaseAssertion, appendCaseClosure, appendCaseDecision, appendCaseEvidencePin, appendCaseEvidencePins, appendCaseManualTrailEvent, appendCaseObservedEffectReview, appendCaseSighting, buildCaseClosureLinkContext, normalizeCaseActions, normalizeCaseAssertions, normalizeCaseClosureHistory, normalizeCaseDecisions, normalizeCaseEvidencePins, normalizeCaseManualTrail, normalizeCaseObservedEffectHistory, normalizeCaseSightings, updateCaseAction, updateCaseAssertion, } from "./case-response-model.mjs";
 import { MAX_CASES, MAX_NOTES_PER_CASE, } from "./case-record-contracts.mjs";
-import { PUBLISHED_V2_3_CASE_SCHEMA_VERSION, INCIDENT_CASE_SCHEMA_VERSION, MAX_CASE_OBJECTIVE_LENGTH } from "../contracts/case-portability.mjs";
+import { MAX_CASE_OBJECTIVE_LENGTH, MAX_RESPONSE_VALUE_LENGTH } from "../contracts/case-portability.mjs";
+import { caseRecordVersionInput } from "./case-record-version-input.mjs";
 import { readCaseAttachments } from "./case-attachment-model.mjs";
-import { assertCurrentRecheckQuestion, assertRecheckNonReproduction, readCaseRecheckAnswerContext } from "./case-recheck-model.mjs";
+import { readCaseEvidenceLinks, appendCaseEvidenceLink, withdrawCaseEvidenceLink } from "./case-evidence-links.mjs";
+import { assertCurrentRecheckQuestion, assertRecheckNonReproduction, assertCaseObjectObservationOutcome, readCaseRecheckAnswerContext } from "./case-recheck-model.mjs";
 import { caseDispositionSupportsDefensiveResponse, caseStatusIsClosed, caseStatusOptionsForDirectEdit, caseStatusRequiresClosure, isReviewedCaseDisposition, } from "./case-record-decisions.mjs";
 import { DEFAULT_EVIDENCE_SOURCE, EVIDENCE_SOURCE_SET, caseTimestampOrNull, deterministicId, makeId, normalizeDisposition, normalizeDomain, normalizeNoteBody, normalizeReviewReasonCode, normalizeNotes, normalizeSource, normalizeStatus, normalizeTags, objectRecord, safeId, } from "./case-record-core.mjs";
 import { assertCaseBrandProfileIds, normalizeCaseBrandProfileIds, } from "./case-brand-profile-references.mjs";
@@ -15,84 +20,7 @@ import { normalizeEvidenceHistory, } from "./case-evidence-model.mjs";
 import { appendCaseInvestigationBranch, caseInvestigationBranchReferences, normalizeCaseInvestigationBranches, updateCaseInvestigationBranch, } from "./case-investigation-branch-model.mjs";
 export { caseDispositionSupportsDefensiveResponse, caseStatusIsClosed, caseStatusOptionsForDirectEdit, caseStatusRequiresClosure, isReviewedCaseDisposition, };
 export { MAX_CASE_OBJECTIVE_LENGTH };
-export const MAX_CASE_INCIDENT_URL_LENGTH = 1_850;
-export const INCIDENT_CONTEXT_STATEMENT_PREFIX = 'Investigate incident URL: ';
-const OBJECTIVE_PREFIX = 'Objective: ';
-const RETENTION_SEPARATOR = ' | URL retained: ';
-function boundedContextText(value, maximum) {
-    return typeof value === 'string'
-        ? value.replace(/[\u0000-\u001f\u007f]/gu, ' ').replace(/\s+/gu, ' ').trim().slice(0, maximum)
-        : '';
-}
-export function normalizeCaseObjective(value) {
-    return boundedContextText(value, MAX_CASE_OBJECTIVE_LENGTH);
-}
-export function parseIncidentUrlContext(value) {
-    const parsed = parseCredentialFreeHttpUrl(value, MAX_CASE_INCIDENT_URL_LENGTH);
-    if (!parsed)
-        return null;
-    const hostname = parsed.hostname.toLowerCase().replace(/\.$/u, '');
-    const registrableDomain = canonicalRegistrableDomain(hostname);
-    if (!registrableDomain)
-        return null;
-    const exactUrl = parsed.toString();
-    if (exactUrl.length > MAX_CASE_INCIDENT_URL_LENGTH)
-        return null;
-    return Object.freeze({
-        exactUrl,
-        hostname,
-        registrableDomain,
-        originUrl: parsed.origin,
-        hasPath: parsed.pathname !== '/',
-        hasQuery: Boolean(parsed.search),
-        hasFragment: Boolean(parsed.hash),
-    });
-}
-export function caseInvestigationContext(record) {
-    if (!record)
-        return null;
-    for (const assertion of [...record.assertions].reverse()) {
-        if (assertion.kind !== 'next_step' || assertion.state !== 'open'
-            || !assertion.statement.startsWith(INCIDENT_CONTEXT_STATEMENT_PREFIX))
-            continue;
-        const incidentUrl = assertion.statement.slice(INCIDENT_CONTEXT_STATEMENT_PREFIX.length);
-        const parsed = parseIncidentUrlContext(incidentUrl);
-        if (!parsed || parsed.registrableDomain !== record.domain)
-            continue;
-        const rationale = assertion.rationale ?? '';
-        const separatorIndex = rationale.lastIndexOf(RETENTION_SEPARATOR);
-        const objective = separatorIndex > OBJECTIVE_PREFIX.length && rationale.startsWith(OBJECTIVE_PREFIX)
-            ? normalizeCaseObjective(rationale.slice(OBJECTIVE_PREFIX.length, separatorIndex))
-            : '';
-        const retention = separatorIndex >= 0 ? rationale.slice(separatorIndex + RETENTION_SEPARATOR.length) : '';
-        if (!objective || (retention !== 'exact' && retention !== 'origin_only'))
-            continue;
-        return Object.freeze({
-            objective,
-            incidentUrl: parsed.exactUrl,
-            urlRetention: retention,
-            assertionId: assertion.id,
-            updatedAt: assertion.updatedAt,
-        });
-    }
-    return null;
-}
-export function caseInvestigationContextAssertion(input) {
-    const objective = normalizeCaseObjective(input.objective);
-    if (!objective)
-        throw new Error('Enter the investigation objective before retaining Incident context.');
-    const parsed = parseIncidentUrlContext(input.incidentUrl);
-    if (!parsed)
-        throw new Error(`Enter one absolute HTTP(S) Incident URL of at most ${MAX_CASE_INCIDENT_URL_LENGTH} characters without credentials.`);
-    const retention = input.retainExactUrl ? 'exact' : 'origin_only';
-    const retainedUrl = input.retainExactUrl ? parsed.exactUrl : parsed.originUrl;
-    return Object.freeze({
-        statement: `${INCIDENT_CONTEXT_STATEMENT_PREFIX}${retainedUrl}`,
-        rationale: `${OBJECTIVE_PREFIX}${objective}${RETENTION_SEPARATOR}${retention}`,
-        retainedUrl,
-        retention,
-    });
-}
+export * from "./case-incident-context.mjs";
 // ---------------------------------------------------------------------------
 // Case normalization
 // ---------------------------------------------------------------------------
@@ -130,39 +58,42 @@ function normalizeCaseEvidence(record, domain, createdAt, updatedAt, now, source
  */
 export function normalizeCase(raw, existing, nowIso, sourceVersion) {
     const now = caseTimestampOrNull(nowIso) || new Date().toISOString();
-    const record = objectRecord(raw);
-    const domain = normalizeDomain(existing ? existing.domain : record.domain);
+    const input = objectRecord(raw);
+    const domain = normalizeDomain(existing ? existing.domain : input.domain);
     if (!domain)
         return null;
+    const { record, timestampOptions } = caseRecordVersionInput(input, sourceVersion);
     const createdAt = existing ? existing.createdAt : caseTimestampOrNull(record.createdAt, sourceVersion) || now;
     const updatedAt = caseTimestampOrNull(record.updatedAt, sourceVersion) || createdAt;
-    const timestampOptions = {
-        legacyTimestamps: sourceVersion != null && sourceVersion < PUBLISHED_V2_3_CASE_SCHEMA_VERSION,
-        ...(sourceVersion === undefined ? {} : { sourceVersion }),
-    };
     const evidencePins = normalizeCaseEvidencePins(record.evidencePins, updatedAt, timestampOptions);
     const pinIds = new Set(evidencePins.map((item) => item.id));
     const actions = normalizeCaseActions(record.actions, updatedAt, { ...timestampOptions, validEvidencePinIds: pinIds });
+    for (const action of actions)
+        for (const event of action.history)
+            if (event.packetReceipt
+                && (event.packetReceipt.caseId !== record.id || event.packetReceipt.target !== domain))
+                throw new TypeError('The packet receipt belongs to a different Case or target.');
     const assertions = normalizeCaseAssertions(record.assertions, updatedAt, pinIds, timestampOptions);
     const sightings = normalizeCaseSightings(record.sightings, updatedAt, pinIds, timestampOptions);
     const sightingIds = new Set(sightings.map((item) => item.id));
-    const observedEffects = normalizeCaseObservedEffectHistory(sourceVersion != null && sourceVersion < 13 ? undefined : record.observedEffects, updatedAt, pinIds, sightingIds, timestampOptions);
-    const closures = normalizeCaseClosureHistory(sourceVersion != null && sourceVersion < 13 ? undefined : record.closures, updatedAt, new Set(observedEffects.reviews.map((item) => item.id)), new Set(actions.map((item) => item.id)), timestampOptions, buildCaseClosureLinkContext(observedEffects, actions));
+    const observedEffects = normalizeCaseObservedEffectHistory(record.observedEffects, updatedAt, pinIds, sightingIds, timestampOptions);
+    const closures = normalizeCaseClosureHistory(record.closures, updatedAt, new Set(observedEffects.reviews.map((item) => item.id)), new Set(actions.map((item) => item.id)), timestampOptions, buildCaseClosureLinkContext(observedEffects, actions));
     const normalizedStatus = normalizeStatus(record.status);
     const branchReferences = caseInvestigationBranchReferences({ evidencePins, actions, assertions });
     const attachments = readCaseAttachments(record.attachments);
+    const evidenceLinks = readCaseEvidenceLinks(record.evidenceLinks);
     return {
         id: existing ? existing.id : safeId(record.id) || deterministicId(domain),
         domain,
-        title: sourceVersion != null && sourceVersion < INCIDENT_CASE_SCHEMA_VERSION ? '' : normalizeCaseObjective(record.title),
+        title: normalizeCaseObjective(record.title),
         status: caseStatusRequiresClosure(normalizedStatus)
-            && closures.records.length === 0 && !closures.preV13HistoryUnavailable
+            && !closures.records.some(closure => closure.responseObject === undefined) && !closures.preV13HistoryUnavailable
             ? 'reviewing'
             : normalizedStatus,
         disposition: normalizeDisposition(record.disposition),
         reviewReasonCode: normalizeReviewReasonCode(record.reviewReasonCode),
         brandProfileIds: normalizeCaseBrandProfileIds(record.brandProfileIds),
-        tags: normalizeTags(record.tags),
+        ...readCaseWorkflowFields(record, domain, assertions, sourceVersion),
         notes: normalizeNotes(record.notes, now, sourceVersion),
         source: normalizeSource(record.source),
         evidenceHistory: normalizeCaseEvidence(record, domain, createdAt, updatedAt, now, sourceVersion),
@@ -176,6 +107,7 @@ export function normalizeCase(raw, existing, nowIso, sourceVersion) {
         closures,
         branches: normalizeCaseInvestigationBranches(record.branches, updatedAt, branchReferences, timestampOptions),
         ...(attachments === undefined ? {} : { attachments }),
+        ...(evidenceLinks === undefined ? {} : { evidenceLinks }),
         createdAt,
         updatedAt,
     };
@@ -192,6 +124,13 @@ export function createCase(input, nowIso) {
         throw new Error('A valid domain is required to open a case.');
     const noteBody = normalizeNoteBody(input.note);
     const source = normalizeSource(input.source);
+    const workflowMetadata = updateCaseWorkflowMetadata(emptyCaseWorkflowMetadata(), input, domain, now);
+    const scopedCase = { domain, workflowMetadata };
+    for (const raw of [input.evidencePin, ...(Array.isArray(input.evidencePins) ? input.evidencePins : []), input.observedEffectReview, input.closure])
+        assertCaseResponseObject(readCaseResponseObject(objectRecord(raw).responseObject), scopedCase);
+    for (const object of readCaseResponseObjects(objectRecord(input.action).responseObjects) ?? [])
+        assertCaseResponseObject(object, scopedCase);
+    assertCaseResponseObject(readCaseResponseObject(objectRecord(objectRecord(input.assertion).recheck).responseObject), scopedCase);
     const evidencePins = input.evidencePins !== undefined
         ? appendCaseEvidencePins([], input.evidencePins, now)
         : input.evidencePin !== undefined
@@ -212,13 +151,19 @@ export function createCase(input, nowIso) {
         ? appendCaseObservedEffectReview(normalizeCaseObservedEffectHistory(undefined, now), input.observedEffectReview, now, pinIds, new Set(sightings.map((item) => item.id)))
         : normalizeCaseObservedEffectHistory(undefined, now);
     for (const review of observedEffects.reviews) {
+        const pin = evidencePins.find(item => item.id === review.evidencePinId);
+        if (review.responseObject && pin && !sameCaseResponseObject(review.responseObject, pin.responseObject))
+            throw new TypeError('The selected observation evidence does not explicitly concern this exact object.');
+        if (review.responseObject && review.state === 'not_reproduced' && !review.recheck)
+            throw new TypeError('Object-specific non-reproduction requires a saved baseline question and comparable evidence.');
+        assertCaseObjectObservationOutcome(review.objectOutcome, review.recheck, review.completeness, evidencePins, pin, review.observedAt);
         if (!review.recheck)
             continue;
         assertCurrentRecheckQuestion(review.recheck, assertions);
         assertRecheckNonReproduction(review.state, review.recheck, review.completeness, evidencePins, evidencePins.find(pin => pin.id === review.evidencePinId), review.observedAt);
     }
     const closures = input.closure !== undefined
-        ? appendCaseClosure(normalizeCaseClosureHistory(undefined, now), input.closure, now, observedEffects, actions)
+        ? appendCaseClosure(normalizeCaseClosureHistory(undefined, now), input.closure, now, observedEffects, actions, evidencePins)
         : normalizeCaseClosureHistory(undefined, now);
     if (caseStatusRequiresClosure(normalizeStatus(input.status)) && input.closure === undefined) {
         throw new Error('Opening a resolved case requires a deliberate closure reason and its linked review context.');
@@ -227,11 +172,12 @@ export function createCase(input, nowIso) {
         id: makeId(),
         domain,
         title: normalizeCaseObjective(input.title),
-        status: input.closure !== undefined ? 'resolved' : normalizeStatus(input.status),
+        status: input.closure !== undefined && objectRecord(input.closure).responseObject === undefined ? 'resolved' : normalizeStatus(input.status),
         disposition: normalizeDisposition(input.disposition),
         reviewReasonCode: normalizeReviewReasonCode(input.reviewReasonCode),
         brandProfileIds: input.brandProfileIds === undefined ? [] : assertCaseBrandProfileIds(input.brandProfileIds),
         tags: normalizeTags(input.tags),
+        workflowMetadata,
         notes: noteBody ? [{ id: makeId(), body: noteBody, createdAt: now }] : [],
         source,
         evidenceHistory: normalizeEvidenceHistory(input.evidence ? [input.evidence] : [], {
@@ -243,6 +189,7 @@ export function createCase(input, nowIso) {
         decisions: input.decision !== undefined
             ? appendCaseDecision([], input.decision, now)
             : [],
+        ...(input.evidenceLink === undefined ? {} : { evidenceLinks: appendCaseEvidenceLink([], input.evidenceLink, evidencePins, now) }),
         actions,
         assertions,
         manualTrail: input.trailEvent !== undefined
@@ -319,9 +266,36 @@ export function updateCase(cases, id, patch, nowIso) {
     const current = cases[index];
     if (!current)
         throw new Error('That case no longer exists.');
+    if (patch.expectedResponseContext !== undefined && patch.expectedResponseContext !== JSON.stringify(current))
+        throw new TypeError('The Case response context changed after preview. Review the current delivery, scope and evidence before creating this draft.');
+    const workflowMetadata = updateCaseWorkflowMetadata(current.workflowMetadata
+        ?? readCaseWorkflowFields(current, current.domain, current.assertions).workflowMetadata, patch, current.domain, now);
+    const scopedCase = { ...current, workflowMetadata };
+    for (const raw of [patch.evidencePin, ...(Array.isArray(patch.evidencePins) ? patch.evidencePins : []), patch.observedEffectReview, patch.closure]) {
+        assertCaseResponseObject(readCaseResponseObject(objectRecord(raw).responseObject), scopedCase);
+    }
+    for (const raw of [patch.action, patch.actionUpdate, objectRecord(patch.actionUpdate).transition]) {
+        for (const object of readCaseResponseObjects(objectRecord(raw).responseObjects) ?? [])
+            assertCaseResponseObject(object, scopedCase);
+    }
+    for (const raw of [patch.assertion, patch.assertionUpdate, patch.observedEffectReview]) {
+        assertCaseResponseObject(readCaseResponseObject(objectRecord(objectRecord(raw).recheck).responseObject), scopedCase);
+    }
+    if (patch.evidenceLink !== undefined && patch.evidenceLinkWithdrawal !== undefined)
+        throw new TypeError('Record or withdraw one evidence relationship at a time.');
     if (patch.title !== undefined && patch.expectedTitle !== undefined && patch.expectedTitle !== (current.title ?? '')) {
         throw new Error('The incident title changed after this draft was started. Reload and review the current title before saving; your draft has not been applied.');
     }
+    for (const [value, expected, actual, label] of [
+        [patch.status, patch.expectedStatus, current.status, 'status'],
+        [patch.disposition, patch.expectedDisposition, current.disposition, 'disposition'],
+        [patch.reviewReasonCode, patch.expectedReviewReasonCode, current.reviewReasonCode ?? null, 'review reason'],
+        [patch.tags, patch.expectedTags, current.tags, 'tags'],
+    ]) {
+        if (value !== undefined && expected !== undefined && JSON.stringify(expected) !== JSON.stringify(actual)) {
+            throw new Error(`The Case ${label} changed after this edit was started. Reopen the Case to review the current value; your edit has not been applied.`);
+        }
+    }
     let notes = current.notes;
     if (patch.note !== undefined) {
         const body = normalizeNoteBody(patch.note);
@@ -345,6 +319,17 @@ export function updateCase(cases, id, patch, nowIso) {
         evidencePins = appendCaseEvidencePin(evidencePins, patch.evidencePin, now);
     }
     const pinIds = new Set(evidencePins.map((item) => item.id));
+    const correctionInput = patch.action !== undefined ? objectRecord(patch.action) : patch.actionUpdate !== undefined
+        ? { ...current.actions.find(action => action.id === objectRecord(patch.actionUpdate).id), ...objectRecord(patch.actionUpdate) } : null;
+    if (correctionInput?.correction !== undefined)
+        correctionDelivery(current.actions, {
+            originActionId: typeof correctionInput.originActionId === 'string' ? correctionInput.originActionId : null,
+            recipient: typeof correctionInput.recipient === 'string' ? correctionInput.recipient : '',
+            responseObjects: readCaseResponseObjects(correctionInput.responseObjects), correction: readCasePacketCorrection(correctionInput.correction),
+        }, { caseId: current.id, target: current.domain, selectedPinIds: pinIds });
+    const transitionReceipt = readCaseDeliveryPacketReceipt(objectRecord(objectRecord(patch.actionUpdate).transition).packetReceipt);
+    if (transitionReceipt && (transitionReceipt.caseId !== current.id || transitionReceipt.target !== current.domain))
+        throw new TypeError('The packet receipt belongs to a different Case or target.');
     let decisions = current.decisions;
     if (patch.decision !== undefined) {
         decisions = appendCaseDecision(current.decisions, patch.decision, now, pinIds);
@@ -356,6 +341,16 @@ export function updateCase(cases, id, patch, nowIso) {
     if (patch.actionUpdate !== undefined) {
         actions = updateCaseAction(actions, patch.actionUpdate, now, pinIds);
     }
+    if (correctionInput?.correction !== undefined || transitionReceipt) {
+        for (const original of current.actions) {
+            const retained = actions.find(action => action.id === original.id);
+            if (!retained || original.history.some(event => !retained.history.some(next => JSON.stringify(next) === JSON.stringify(event)))
+                || (patch.action !== undefined && JSON.stringify(retained) !== JSON.stringify(original)))
+                throw new TypeError('This linked operation would omit or change historical delivery records within the Case bounds. No correction or receipt was retained.');
+        }
+        if (transitionReceipt && !actions.find(action => action.id === transitionReceipt.actionId)?.history.some(event => JSON.stringify(event.packetReceipt) === JSON.stringify(transitionReceipt)))
+            throw new TypeError('The exact delivery receipt exceeds the retained history bounds. No delivery was recorded.');
+    }
     let assertions = current.assertions;
     if (patch.assertion !== undefined) {
         assertions = appendCaseAssertion(current.assertions, patch.assertion, now, pinIds);
@@ -387,20 +382,28 @@ export function updateCase(cases, id, patch, nowIso) {
             assertCurrentRecheckQuestion(context, assertions);
             assertRecheckNonReproduction(review.state, context, String(review.completeness), evidencePins, evidencePins.find(pin => pin.id === review.evidencePinId), typeof review.observedAt === 'string' ? review.observedAt : null);
         }
+        const responseObject = readCaseResponseObject(review.responseObject);
+        const pin = evidencePins.find(item => item.id === review.evidencePinId);
+        assertCaseObjectObservationOutcome(review.objectOutcome, context, String(review.completeness), evidencePins, pin, typeof review.observedAt === 'string' ? review.observedAt : null);
+        if (responseObject && pin && !sameCaseResponseObject(responseObject, pin.responseObject))
+            throw new TypeError('The selected observation evidence does not explicitly concern this exact object.');
+        if (responseObject && review.state === 'not_reproduced' && !context)
+            throw new TypeError('Object-specific non-reproduction requires a saved baseline question and comparable evidence.');
         observedEffects = appendCaseObservedEffectReview(observedEffects, patch.observedEffectReview, now, pinIds, new Set(sightings.map((item) => item.id)));
     }
     let closures = normalizeCaseClosureHistory(current.closures, current.updatedAt, new Set(observedEffects.reviews.map((item) => item.id)), new Set(actions.map((item) => item.id)), {}, buildCaseClosureLinkContext(observedEffects, actions));
     if (patch.closure !== undefined) {
-        closures = appendCaseClosure(closures, patch.closure, now, observedEffects, actions);
+        closures = appendCaseClosure(closures, patch.closure, now, observedEffects, actions, evidencePins);
     }
     if (caseStatusRequiresClosure(patch.status) && patch.closure === undefined) {
         throw new Error('Resolve this case through the deliberate closure review so the reason and evidence state remain explicit.');
     }
     const record = {
         ...current,
+        workflowMetadata,
         title: patch.title === undefined ? current.title ?? '' : normalizeCaseObjective(patch.title),
         status: patch.closure !== undefined
-            ? 'resolved'
+            ? objectRecord(patch.closure).responseObject !== undefined ? current.status : 'resolved'
             : patch.status !== undefined ? normalizeStatus(patch.status) : current.status,
         disposition: patch.disposition !== undefined ? normalizeDisposition(patch.disposition) : current.disposition,
         reviewReasonCode: patch.reviewReasonCode !== undefined
@@ -413,6 +416,11 @@ export function updateCase(cases, id, patch, nowIso) {
         source,
         evidenceHistory,
         evidencePins,
+        ...((patch.evidenceLink !== undefined || patch.evidenceLinkWithdrawal !== undefined) ? {
+            evidenceLinks: patch.evidenceLink !== undefined
+                ? appendCaseEvidenceLink(current.evidenceLinks ?? [], patch.evidenceLink, evidencePins, now)
+                : withdrawCaseEvidenceLink(current.evidenceLinks ?? [], patch.evidenceLinkWithdrawal, now),
+        } : {}),
         decisions,
         actions,
         assertions,
@@ -537,26 +545,7 @@ export function recordCaseInvestigationContext(cases, id, input, nowIso) {
     if (!parsed || parsed.registrableDomain !== current.domain) {
         throw new Error(`The Incident URL must belong to the Case domain ${current.domain}.`);
     }
-    const context = caseInvestigationContextAssertion(input);
-    const existing = caseInvestigationContext(current);
-    return updateCase(cases, id, existing
-        ? {
-            assertionUpdate: {
-                id: existing.assertionId,
-                statement: context.statement,
-                rationale: context.rationale,
-                state: 'open',
-            },
-        }
-        : {
-            assertion: {
-                kind: 'next_step',
-                statement: context.statement,
-                rationale: context.rationale,
-                evidenceRelations: [],
-                state: 'open',
-            },
-        }, nowIso);
+    return updateCase(cases, id, { investigationContext: input }, nowIso);
 }
 export function recordCaseRecheckOutcome(cases, id, input, nowIso) {
     const now = caseTimestampOrNull(nowIso) || new Date().toISOString();
@@ -577,8 +566,10 @@ export function recordCaseRecheckOutcome(cases, id, input, nowIso) {
             observedAt: input.observedAt,
             collectionDepth: input.collectionDepth,
             observationHostname: input.observationHostname,
+            ...(input.responseObject ? { responseObject: input.responseObject } : {}),
             completeness: input.completeness,
-            truncated: false,
+            truncated: input.comparisonTruncated === true
+                || (typeof input.comparisonSummary === 'string' && input.comparisonSummary.length > MAX_RESPONSE_VALUE_LENGTH),
             limitations: input.limitations,
         },
     }, now);
@@ -596,6 +587,8 @@ export function recordCaseRecheckOutcome(cases, id, input, nowIso) {
             followUpAt: input.followUpAt,
             limitations: input.limitations,
             ...(input.recheck ? { recheck: input.recheck } : {}),
+            ...(input.responseObject ? { responseObject: input.responseObject } : {}),
+            ...(input.objectOutcome ? { objectOutcome: input.objectOutcome } : {}),
         },
     }, now);
 }

package/packages/cases/case-record-projection.mjs

@@ -1,4 +1,4 @@
-import { PUBLIC_CASE_SCHEMA_VERSION, INCIDENT_CASE_SCHEMA_VERSION } from "../contracts/case-portability.mjs";
+import { PUBLIC_CASE_SCHEMA_VERSION, INCIDENT_CASE_SCHEMA_VERSION, EVIDENCE_FOLLOW_UP_CASE_SCHEMA_VERSION } from "../contracts/case-portability.mjs";
 import { caseStatusIsClosed } from "./case-record-decisions.mjs";
 const PRESERVE = Object.freeze({
     durable: 'preserve', internal: 'preserve', trusted: 'preserve', public: 'preserve',
@@ -86,6 +86,12 @@ const CASE_FIELD_RULES = Object.freeze({
         audienceExclusions: { public: { label: 'Brand Profile references', order: 2 } },
     }),
     tags: fieldRule('tags', PRESERVE, (record) => [...record.tags]),
+    workflowMetadata: fieldRule('workflowMetadata', PUBLIC_REDACT, (record, profile) => (record.workflowMetadata === undefined ? undefined : profile === 'public'
+        ? { types: [...record.workflowMetadata.types], incidentTargets: [], investigationContext: null }
+        : structuredClone(record.workflowMetadata)), {
+        nestedSensitiveFields: ['incidentTargets', 'investigationContext'],
+        audienceExclusions: { public: { label: 'Private incident links and investigation context', order: 4, sinceVersion: EVIDENCE_FOLLOW_UP_CASE_SCHEMA_VERSION } },
+    }),
     notes: fieldRule('notes', SHARED_EXCLUDE, (record, profile) => (profile === 'trusted' || profile === 'public'
         ? []
         : record.notes.map((item) => ({ ...item }))), {
@@ -96,14 +102,26 @@ const CASE_FIELD_RULES = Object.freeze({
     }),
     source: preservedField('source'),
     evidenceHistory: fieldRule('evidenceHistory', PRESERVE, (record) => structuredClone(record.evidenceHistory)),
-    evidencePins: fieldRule('evidencePins', PRESERVE, (record) => structuredClone(record.evidencePins)),
+    evidencePins: fieldRule('evidencePins', PUBLIC_REDACT, (record, profile) => structuredClone(record.evidencePins).map(pin => {
+        if (profile !== 'public')
+            return pin;
+        const { responseObject: _scope, infrastructureObservation: _infrastructure, ...publicPin } = pin;
+        return publicPin;
+    }), { nestedSensitiveFields: ['responseObject', 'infrastructureObservation'], audienceExclusions: { public: { label: 'Exact-object evidence scope and infrastructure observations', order: 4, sinceVersion: 18 } } }),
+    evidenceLinks: fieldRule('evidenceLinks', PUBLIC_EXCLUDE, (record, profile) => (profile === 'public' ? undefined : structuredClone(record.evidenceLinks)), { audienceExclusions: { public: { label: 'Analyst evidence relationships', order: 4, sinceVersion: EVIDENCE_FOLLOW_UP_CASE_SCHEMA_VERSION } } }),
     decisions: fieldRule('decisions', PRESERVE, (record) => structuredClone(record.decisions)),
     actions: fieldRule('actions', TRUSTED_REDACT_PUBLIC_EXCLUDE, (record, profile) => (profile === 'public'
         ? []
         : profile === 'trusted'
-            ? structuredClone(record.actions).map((item) => ({ ...item, recipient: '[redacted]' }))
+            ? structuredClone(record.actions).map((item) => {
+                const { correction: _privateCorrection, ...shared } = item;
+                return { ...shared, recipient: '[redacted]', history: shared.history.map(event => {
+                        const { packetReceipt: _privateReceipt, ...sharedEvent } = event;
+                        return sharedEvent;
+                    }) };
+            })
             : structuredClone(record.actions)), {
-        nestedSensitiveFields: ['recipient'],
+        nestedSensitiveFields: ['recipient', 'responseObjects', 'correction', 'packetReceipt'],
         audienceExclusions: {
             trusted: { label: 'Recipient values', order: 2 },
             public: { label: 'Actions and recipient values', order: 3 },
@@ -184,6 +202,7 @@ const OUTSIDE_SCHEMA_EXCLUSIONS = Object.freeze({
 });
 function currentAudienceExclusions(audience, caseVersion) {
     const entries = [
+        ...(audience === 'trusted' && caseVersion >= 19 ? [{ label: 'Private correction content and exact delivery receipts', order: 2 }] : []),
         ...Object.values(CASE_FIELD_RULES).flatMap((rule) => (rule.audienceExclusions[audience] ? [rule.audienceExclusions[audience]] : [])),
         OUTSIDE_SCHEMA_EXCLUSIONS[audience],
     ];

package/packages/cases/case-record-version-input.mjs

@@ -0,0 +1,41 @@
+import { EVIDENCE_FOLLOW_UP_CASE_SCHEMA_VERSION, INCIDENT_CASE_SCHEMA_VERSION, PUBLISHED_V2_CASE_SCHEMA_VERSION, PUBLISHED_V2_3_CASE_SCHEMA_VERSION, OBJECT_RESPONSE_CASE_SCHEMA_VERSION, DELIVERY_CORRECTION_CASE_SCHEMA_VERSION, } from "../contracts/case-portability.mjs";
+/** Adapt declared historical fields before ordinary current-record recovery. */
+export function caseRecordVersionInput(record, sourceVersion) {
+    const declared = sourceVersion != null;
+    if (declared && sourceVersion < DELIVERY_CORRECTION_CASE_SCHEMA_VERSION && Array.isArray(record.actions)
+        && record.actions.some(action => action && typeof action === 'object' && (action.correction !== undefined
+            || Array.isArray(action.history) && action.history.some((event) => event?.packetReceipt !== undefined)))) {
+        throw new TypeError('Delivery receipts and corrections require Case schema 19; historical deliveries were not reinterpreted.');
+    }
+    if (declared && sourceVersion < OBJECT_RESPONSE_CASE_SCHEMA_VERSION) {
+        const items = (value) => Array.isArray(value) ? value.filter((item) => !!item && typeof item === 'object' && !Array.isArray(item)) : [];
+        const object = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+        const pins = items(record.evidencePins);
+        const actions = items(record.actions);
+        const reviews = items(object(record.observedEffects).reviews);
+        const closures = items(object(record.closures).records);
+        const questions = [...items(record.assertions), ...reviews].map(item => object(item.recheck));
+        const events = actions.flatMap(action => items(action.history));
+        if (pins.some(pin => pin.responseObject !== undefined || pin.infrastructureObservation !== undefined)
+            || actions.some(action => action.responseObjects !== undefined)
+            || events.some(event => event.responseObjects !== undefined || event.objectOutcome !== undefined)
+            || [...reviews, ...closures, ...questions].some(item => item.responseObject !== undefined || item.objectOutcome !== undefined)
+            || [...items(record.evidenceHistory), object(record.evidence)].some(snapshot => snapshot.hasExternalPasswordForm !== undefined)) {
+            throw new TypeError('Object response and password-form attribution fields require Case schema 18; historical evidence was not reinterpreted.');
+        }
+    }
+    if (record.evidenceLinks !== undefined && declared && sourceVersion < EVIDENCE_FOLLOW_UP_CASE_SCHEMA_VERSION) {
+        throw new TypeError('Evidence relationships require the current Case schema.');
+    }
+    return {
+        record: declared && sourceVersion < INCIDENT_CASE_SCHEMA_VERSION ? {
+            ...record,
+            ...(sourceVersion < PUBLISHED_V2_CASE_SCHEMA_VERSION ? { observedEffects: undefined, closures: undefined } : {}),
+            title: '',
+        } : record,
+        timestampOptions: {
+            legacyTimestamps: declared && sourceVersion < PUBLISHED_V2_3_CASE_SCHEMA_VERSION,
+            ...(sourceVersion === undefined ? {} : { sourceVersion }),
+        },
+    };
+}