@slicedearth/whoisleuth-cli 2.3.0 → 2.5.1

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

@@ -1,9 +1,10 @@
 // Pure, framework-neutral analyst-case records, evidence histories, bounded
 // record normalization, and analyst updates.
-import { CASE_SCHEMA_VERSION, CASE_REVIEW_REASONS, CASE_SOURCES, DEFAULT_DISPOSITION, DEFAULT_SOURCE, DEFAULT_STATUS, EVIDENCE_SOURCES, MAX_DOMAIN_LENGTH, MAX_NOTES_PER_CASE, MAX_NOTE_LENGTH, MAX_TAGS_PER_CASE, MAX_TAG_LENGTH, } from "./case-record-contracts.mjs";
+import { CASE_REVIEW_REASONS, CASE_SOURCES, DEFAULT_DISPOSITION, DEFAULT_SOURCE, DEFAULT_STATUS, EVIDENCE_SOURCES, MAX_DOMAIN_LENGTH, MAX_NOTES_PER_CASE, MAX_NOTE_LENGTH, MAX_TAGS_PER_CASE, MAX_TAG_LENGTH, } from "./case-record-contracts.mjs";
 import { dispositionLabel, isValidDisposition, isValidStatus, statusLabel, } from "./case-record-decisions.mjs";
 import { normalizeExplicitIsoTimestamp, normalizeLegacyIsoTimestamp } from "../evidence/observation.mjs";
-import { canonicalRegistrableDomain } from "../../lib/registrable-domain.mjs";
+import { PUBLISHED_V2_3_CASE_SCHEMA_VERSION } from "../contracts/case-portability.mjs";
+import { canonicalRegistrableDomain } from "../analysis/registrable-domain.mjs";
 // Forward-version policy (two distinct guarantees):
 //   - A locally-stored envelope that declares a version greater than this is
 //     still read best-effort on load (known fields kept, unknown dropped), but
@@ -163,7 +164,7 @@ export function caseTimestampOrNull(value, sourceVersion) {
         return explicit;
     return sourceVersion !== undefined
         && sourceVersion !== null
-        && sourceVersion < CASE_SCHEMA_VERSION
+        && sourceVersion < PUBLISHED_V2_3_CASE_SCHEMA_VERSION
         ? normalizeLegacyIsoTimestamp(value)
         : null;
 }

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

@@ -1,103 +1,24 @@
 // Pure, framework-neutral analyst-case records, evidence histories, bounded
 // record normalization, and analyst updates.
-import { canonicalRegistrableDomain } from "../../lib/registrable-domain.mjs";
+import { normalizeCaseObjective, parseIncidentUrlContext, } from "./case-incident-context.mjs";
+import { selectExistingCase } from "./case-selection.mjs";
+import { emptyCaseWorkflowMetadata, updateCaseWorkflowMetadata } from "./case-workflow-metadata.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 { CASE_SCHEMA_VERSION, MAX_CASES, MAX_NOTES_PER_CASE, } from "./case-record-contracts.mjs";
+import { MAX_CASES, MAX_NOTES_PER_CASE, } from "./case-record-contracts.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 { readCaseEvidenceLinks, appendCaseEvidenceLink, withdrawCaseEvidenceLink } from "./case-evidence-links.mjs";
+import { assertCurrentRecheckQuestion, assertRecheckNonReproduction, 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";
 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 const MAX_CASE_OBJECTIVE_LENGTH = 320;
-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) {
-    if (typeof value !== 'string' || !value || value.length > MAX_CASE_INCIDENT_URL_LENGTH)
-        return null;
-    if (/[\u0000-\u001f\u007f]/u.test(value) || value.trim() !== value)
-        return null;
-    let parsed;
-    try {
-        parsed = new URL(value);
-    }
-    catch {
-        return null;
-    }
-    if (!['http:', 'https:'].includes(parsed.protocol) || parsed.username || parsed.password || !parsed.hostname)
-        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 { MAX_CASE_OBJECTIVE_LENGTH };
+export * from "./case-incident-context.mjs";
 // ---------------------------------------------------------------------------
 // Case normalization
 // ---------------------------------------------------------------------------
@@ -135,29 +56,29 @@ 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 < 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 });
     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: normalizeCaseObjective(record.title),
         status: caseStatusRequiresClosure(normalizedStatus)
             && closures.records.length === 0 && !closures.preV13HistoryUnavailable
             ? 'reviewing'
@@ -165,7 +86,7 @@ export function normalizeCase(raw, existing, nowIso, sourceVersion) {
         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),
@@ -178,6 +99,8 @@ export function normalizeCase(raw, existing, nowIso, sourceVersion) {
         observedEffects,
         closures,
         branches: normalizeCaseInvestigationBranches(record.branches, updatedAt, branchReferences, timestampOptions),
+        ...(attachments === undefined ? {} : { attachments }),
+        ...(evidenceLinks === undefined ? {} : { evidenceLinks }),
         createdAt,
         updatedAt,
     };
@@ -213,6 +136,12 @@ export function createCase(input, nowIso) {
     const observedEffects = input.observedEffectReview !== undefined
         ? appendCaseObservedEffectReview(normalizeCaseObservedEffectHistory(undefined, now), input.observedEffectReview, now, pinIds, new Set(sightings.map((item) => item.id)))
         : normalizeCaseObservedEffectHistory(undefined, now);
+    for (const review of observedEffects.reviews) {
+        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)
         : normalizeCaseClosureHistory(undefined, now);
@@ -222,11 +151,13 @@ export function createCase(input, nowIso) {
     return {
         id: makeId(),
         domain,
+        title: normalizeCaseObjective(input.title),
         status: input.closure !== 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: updateCaseWorkflowMetadata(emptyCaseWorkflowMetadata(), input, domain, now),
         notes: noteBody ? [{ id: makeId(), body: noteBody, createdAt: now }] : [],
         source,
         evidenceHistory: normalizeEvidenceHistory(input.evidence ? [input.evidence] : [], {
@@ -238,6 +169,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
@@ -254,25 +186,46 @@ export function createCase(input, nowIso) {
     };
 }
 /**
- * Opens the existing case for a domain, or creates one. Returns a new array
+ * Opens an explicitly selected or unambiguous Case, or creates one. Returns a new array
  * (callers persist it) plus the resolved record and whether it was created.
  * @param {CaseRecord[]} cases
  * @param {{ domain: unknown, status?: unknown, disposition?: unknown, source?: unknown, tags?: unknown, evidence?: unknown, note?: unknown }} input
  * @param {string} [nowIso]
  * @returns {{ cases: CaseRecord[], record: CaseRecord, created: boolean }}
  */
-export function openOrCreateCase(cases, input, nowIso) {
+export function openOrCreateCase(cases, input, nowIso, selection = {}) {
     const domain = normalizeDomain(input.domain);
     if (!domain)
         throw new Error('A valid domain is required to open a case.');
-    const existing = cases.find((item) => item.domain === domain);
+    const existing = selectExistingCase(cases, domain, selection);
     if (existing)
         return { cases, record: existing, created: false };
     if (cases.length >= MAX_CASES)
         throw new Error(`Cases are limited to ${MAX_CASES}. Delete or export some first.`);
     const record = createCase({ ...input, domain }, nowIso);
+    if (cases.some(existingCase => existingCase.id === record.id))
+        throw new Error('A unique Case ID could not be allocated. No data was changed; try again.');
     return { cases: [record, ...cases], record, created: true };
 }
+/** Start a separate incident; reuse only the deliberately selected observation. */
+export function createCaseIncident(cases, input, nowIso) {
+    const domain = normalizeDomain(input.domain);
+    const title = normalizeCaseObjective(input.title);
+    if (!domain)
+        throw new Error('Enter a valid domain for the incident.');
+    if (!title)
+        throw new Error('Enter a title that distinguishes this incident.');
+    if (typeof input.title === 'string' && input.title.trim().length > MAX_CASE_OBJECTIVE_LENGTH)
+        throw new Error(`Incident titles are limited to ${MAX_CASE_OBJECTIVE_LENGTH} characters.`);
+    let evidence;
+    if (input.reuse) {
+        const source = cases.find(record => record.id === input.reuse?.caseId && record.domain === domain);
+        evidence = source?.evidenceHistory.find(snapshot => snapshot.id === input.reuse?.snapshotId);
+        if (!evidence)
+            throw new Error('The selected source observation is no longer available for this domain. No Case was created.');
+    }
+    return openOrCreateCase(cases, { domain, title, ...(evidence ? { evidence: structuredClone(evidence) } : {}) }, nowIso, { newIncident: true });
+}
 /**
  * Applies a partial update to one case by id, bumping updatedAt. A `note` in
  * the patch is appended (respecting the per-case note bound); a `tags` array
@@ -293,6 +246,21 @@ export function updateCase(cases, id, patch, nowIso) {
     const current = cases[index];
     if (!current)
         throw new Error('That case no longer exists.');
+    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);
@@ -352,6 +320,12 @@ export function updateCase(cases, id, patch, nowIso) {
     }
     let observedEffects = normalizeCaseObservedEffectHistory(current.observedEffects, current.updatedAt, pinIds, new Set(sightings.map((item) => item.id)));
     if (patch.observedEffectReview !== undefined) {
+        const review = objectRecord(patch.observedEffectReview);
+        const context = readCaseRecheckAnswerContext(review.recheck);
+        if (context) {
+            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);
+        }
         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));
@@ -363,6 +337,9 @@ export function updateCase(cases, id, patch, nowIso) {
     }
     const record = {
         ...current,
+        workflowMetadata: updateCaseWorkflowMetadata(current.workflowMetadata
+            ?? readCaseWorkflowFields(current, current.domain, current.assertions).workflowMetadata, patch, current.domain, now),
+        title: patch.title === undefined ? current.title ?? '' : normalizeCaseObjective(patch.title),
         status: patch.closure !== undefined
             ? 'resolved'
             : patch.status !== undefined ? normalizeStatus(patch.status) : current.status,
@@ -377,6 +354,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,
@@ -394,8 +376,8 @@ export function updateCase(cases, id, patch, nowIso) {
 }
 /**
  * Records one reviewed conclusion as a single pure Case mutation. The selected
- * observations become bounded Case pins before the decision is created, so the
- * decision cannot point at absent evidence. Counterevidence is retained as a
+ * observations become bounded Case pins or reference existing retained pins,
+ * so the decision cannot point at absent evidence. Counterevidence is retained as a
  * separate resolved contradiction assertion rather than being hidden inside a
  * favourable disposition.
  */
@@ -422,14 +404,36 @@ export function recordCaseConclusion(cases, id, input, nowIso) {
     if (!current)
         throw new Error('That case no longer exists.');
     const existingPinIds = new Set(current.evidencePins.map((pin) => pin.id));
-    const withPins = updateCase(cases, id, {
-        evidencePins: input.evidence.map((item) => item.pin),
-    }, now);
+    const selectedExisting = new Set();
+    for (const item of input.evidence) {
+        if (Object.hasOwn(item, 'pin') === Object.hasOwn(item, 'pinId'))
+            throw new Error('Select one new pin or one retained pin ID for each conclusion fact.');
+        if (Object.hasOwn(item, 'pinId')) {
+            if (typeof item.pinId !== 'string' || !existingPinIds.has(item.pinId))
+                throw new Error('The selected conclusion pin is no longer retained in this Case.');
+            if (selectedExisting.has(item.pinId))
+                throw new Error('Select each retained conclusion pin once.');
+            selectedExisting.add(item.pinId);
+        }
+    }
+    const newEvidence = input.evidence.filter(item => Object.hasOwn(item, 'pin'));
+    const withPins = newEvidence.length
+        ? updateCase(cases, id, { evidencePins: newEvidence.map(item => item.pin) }, now)
+        : { cases, record: current };
     const addedPins = withPins.record.evidencePins.filter((pin) => !existingPinIds.has(pin.id));
-    if (addedPins.length !== input.evidence.length) {
+    if (addedPins.length !== newEvidence.length) {
         throw new Error('The selected conclusion evidence could not be retained completely.');
     }
-    const supportingPinIds = addedPins.flatMap((pin, index) => (input.evidence[index]?.stance === 'supports' ? [pin.id] : []));
+    let nextAdded = 0;
+    const selectedPins = input.evidence.map(item => {
+        const pin = Object.hasOwn(item, 'pinId')
+            ? withPins.record.evidencePins.find(pin => pin.id === item.pinId)
+            : addedPins[nextAdded++];
+        if (!pin)
+            throw new Error('The selected conclusion evidence could not be retained completely.');
+        return pin;
+    });
+    const supportingPinIds = selectedPins.flatMap((pin, index) => (input.evidence[index]?.stance === 'supports' ? [pin.id] : []));
     let concluded = updateCase(withPins.cases, id, {
         disposition,
         reviewReasonCode,
@@ -439,7 +443,7 @@ export function recordCaseConclusion(cases, id, input, nowIso) {
             evidencePinIds: supportingPinIds,
         },
     }, now);
-    const contradictionRelations = addedPins.flatMap((pin, index) => (input.evidence[index]?.stance === 'contradicts'
+    const contradictionRelations = selectedPins.flatMap((pin, index) => (input.evidence[index]?.stance === 'contradicts'
         ? [{ evidencePinId: pin.id, stance: 'contradicts' }]
         : []));
     if (contradictionRelations.length) {
@@ -454,7 +458,7 @@ export function recordCaseConclusion(cases, id, input, nowIso) {
             },
         }, now);
     }
-    const unresolvedRelations = addedPins.flatMap((pin, index) => (input.evidence[index]?.stance === 'unresolved'
+    const unresolvedRelations = selectedPins.flatMap((pin, index) => (input.evidence[index]?.stance === 'unresolved'
         ? [{ evidencePinId: pin.id, stance: 'unresolved' }]
         : []));
     if (unresolvedRelations.length) {
@@ -479,32 +483,15 @@ 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();
     const current = cases.find((item) => item.id === id);
     if (!current)
         throw new Error('That case no longer exists.');
+    if (input.recheck && input.observationHostname !== input.recheck.targetHostname)
+        throw new Error('This recheck concerns a different or unknown hostname. Recollect the saved question target before recording its answer.');
     const beforePinIds = new Set(current.evidencePins.map((pin) => pin.id));
     const withPin = updateCase(cases, id, {
         evidencePin: {
@@ -516,8 +503,10 @@ export function recordCaseRecheckOutcome(cases, id, input, nowIso) {
             sourceState: 'reviewed',
             observedAt: input.observedAt,
             collectionDepth: input.collectionDepth,
+            observationHostname: input.observationHostname,
             completeness: input.completeness,
-            truncated: false,
+            truncated: input.comparisonTruncated === true
+                || (typeof input.comparisonSummary === 'string' && input.comparisonSummary.length > MAX_RESPONSE_VALUE_LENGTH),
             limitations: input.limitations,
         },
     }, now);
@@ -534,6 +523,7 @@ export function recordCaseRecheckOutcome(cases, id, input, nowIso) {
             evidencePinId: comparisonPin.id,
             followUpAt: input.followUpAt,
             limitations: input.limitations,
+            ...(input.recheck ? { recheck: input.recheck } : {}),
         },
     }, now);
 }

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

@@ -1,4 +1,4 @@
-import { PUBLIC_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',
@@ -71,6 +71,12 @@ function publicClosureHistory(preV13HistoryUnavailable) {
 const CASE_FIELD_RULES = Object.freeze({
     id: preservedField('id'),
     domain: preservedField('domain'),
+    title: fieldRule('title', SHARED_EXCLUDE, (record, profile) => (profile === 'trusted' || profile === 'public' ? '' : record.title ?? ''), {
+        audienceExclusions: {
+            trusted: { label: 'Case titles', order: 1, sinceVersion: INCIDENT_CASE_SCHEMA_VERSION },
+            public: { label: 'Case titles', order: 1, sinceVersion: INCIDENT_CASE_SCHEMA_VERSION },
+        },
+    }),
     status: fieldRule('status', PUBLIC_TRANSFORM, (record, profile) => (profile === 'public' && caseStatusIsClosed(record.status) && record.closures.records.length
         ? 'reviewing'
         : record.status)),
@@ -80,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 }))), {
@@ -91,6 +103,7 @@ 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)),
+    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'
         ? []
@@ -133,6 +146,12 @@ const CASE_FIELD_RULES = Object.freeze({
     branches: fieldRule('branches', PUBLIC_EXCLUDE, (record, profile) => (profile === 'public' ? [] : structuredClone(record.branches ?? [])), {
         audienceExclusions: { public: { label: 'Investigation branches', order: 5 } },
     }),
+    attachments: fieldRule('attachments', SHARED_EXCLUDE, (record, profile) => (profile === 'trusted' || profile === 'public' ? undefined : structuredClone(record.attachments)), {
+        audienceExclusions: {
+            trusted: { label: 'Retained file references and provenance', order: 5, sinceVersion: INCIDENT_CASE_SCHEMA_VERSION },
+            public: { label: 'Retained file references and provenance', order: 5, sinceVersion: INCIDENT_CASE_SCHEMA_VERSION },
+        },
+    }),
     createdAt: preservedField('createdAt'),
     updatedAt: preservedField('updatedAt'),
 });
@@ -140,10 +159,13 @@ function projectCase(record, profile) {
     const projected = {};
     for (const key of Object.keys(CASE_FIELD_RULES)) {
         const rule = CASE_FIELD_RULES[key];
+        const value = rule.value(record, profile);
+        if (value === undefined)
+            continue;
         Object.defineProperty(projected, key, {
             configurable: true,
             enumerable: true,
-            value: rule.value(record, profile),
+            value,
             writable: true,
         });
     }
@@ -167,38 +189,26 @@ const OUTSIDE_SCHEMA_EXCLUSIONS = Object.freeze({
     trusted: Object.freeze({ label: 'Raw upstream payloads and credentials', order: 4 }),
     public: Object.freeze({ label: 'Raw upstream payloads and credentials', order: 7 }),
 });
-function currentAudienceExclusions(audience) {
+function currentAudienceExclusions(audience, caseVersion) {
     const entries = [
         ...Object.values(CASE_FIELD_RULES).flatMap((rule) => (rule.audienceExclusions[audience] ? [rule.audienceExclusions[audience]] : [])),
         OUTSIDE_SCHEMA_EXCLUSIONS[audience],
     ];
     const orderByLabel = new Map();
-    const labelByOrder = new Map();
     for (const entry of entries) {
+        if (entry.sinceVersion !== undefined && caseVersion < entry.sinceVersion)
+            continue;
         if (!entry.label || entry.label.length > 160 || entry.label.trim() !== entry.label
             || !Number.isSafeInteger(entry.order) || entry.order < 1 || entry.order > 64) {
             throw new TypeError('Case audience exclusion metadata is malformed or exceeds its bound.');
         }
         const prior = orderByLabel.get(entry.label);
-        if (prior !== undefined && prior !== entry.order) {
-            throw new TypeError(`Case audience exclusion ${entry.label} has conflicting presentation order.`);
-        }
-        const priorLabel = labelByOrder.get(entry.order);
-        if (priorLabel !== undefined && priorLabel !== entry.label) {
-            throw new TypeError(`Case audience exclusions ${priorLabel} and ${entry.label} share a presentation order.`);
-        }
-        orderByLabel.set(entry.label, entry.order);
-        labelByOrder.set(entry.order, entry.label);
+        orderByLabel.set(entry.label, Math.min(prior ?? entry.order, entry.order));
     }
     return Object.freeze([...orderByLabel]
-        .sort((left, right) => left[1] - right[1])
+        .sort((left, right) => left[1] - right[1] || (left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0))
         .map(([label]) => label));
 }
-const CURRENT_AUDIENCE_EXCLUSIONS = Object.freeze({
-    internal: currentAudienceExclusions('internal'),
-    trusted: currentAudienceExclusions('trusted'),
-    public: currentAudienceExclusions('public'),
-});
 // Schema 12 is an immutable public compatibility contract and deliberately
 // remains independent of the current field-policy projection.
 const PUBLIC_V12_EXCLUSIONS = Object.freeze([
@@ -213,6 +223,6 @@ const PUBLIC_V12_EXCLUSIONS = Object.freeze([
 export function caseAudienceExclusions(audience, caseVersion) {
     return audience === 'public' && caseVersion === PUBLIC_CASE_SCHEMA_VERSION
         ? PUBLIC_V12_EXCLUSIONS
-        : CURRENT_AUDIENCE_EXCLUSIONS[audience];
+        : currentAudienceExclusions(audience, caseVersion);
 }
 export { CASE_FIELD_RULES };

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

@@ -0,0 +1,19 @@
+import { EVIDENCE_FOLLOW_UP_CASE_SCHEMA_VERSION, INCIDENT_CASE_SCHEMA_VERSION, PUBLISHED_V2_CASE_SCHEMA_VERSION, PUBLISHED_V2_3_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 (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 }),
+        },
+    };
+}