@slicedearth/whoisleuth-cli 2.2.0 → 2.4.0

package/packages/cases/case-export-input.mjs

@@ -0,0 +1,53 @@
+import { boundedJsonLimitsForBytes, parseBoundedJsonObject } from "../../lib/bounded-json.mjs";
+import { canonicalArtifactJsonV2 } from "../evidence/artifact-integrity.mjs";
+import { normalizeExplicitIsoTimestamp } from "../evidence/observation.mjs";
+import { CASE_SCHEMA_VERSION, CLI_CASE_PACK_INPUT_CASE_VERSIONS, MAX_CASE_STORE_BYTES, MAX_EDITABLE_CASE_INPUT_BYTES, PUBLISHED_V2_3_CASE_SCHEMA_VERSION } from "../contracts/case-portability.mjs";
+import { normalizeCaseStore } from "./case-migration-model.mjs";
+import { serializeCaseStore } from "./case-storage-model.mjs";
+/** Historical wire shape remains independent of current in-memory defaults. */
+export function canonicalCaseExportProjection(cases, caseVersion) {
+    if (caseVersion !== PUBLISHED_V2_3_CASE_SCHEMA_VERSION)
+        return [...cases];
+    return cases.map((value) => {
+        if ([...value.evidencePins, ...value.sightings].some((item) => item.observedAt === null)) {
+            throw new TypeError('The published Case 15 format requires a known observation time on each retained pin and sighting.');
+        }
+        const { title: _title, ...published } = value;
+        return {
+            ...published,
+            sightings: [...value.sightings].sort((left, right) => Date.parse(left.observedAt) - Date.parse(right.observedAt)
+                || (left.id < right.id ? -1 : left.id > right.id ? 1 : 0)),
+        };
+    });
+}
+/** Editing never silently repairs, drops or truncates an imported record. */
+export function readEditableCaseExport(input) {
+    const root = parseBoundedJsonObject(input, {
+        label: 'Case file', maximumBytes: MAX_EDITABLE_CASE_INPUT_BYTES,
+        limits: boundedJsonLimitsForBytes(MAX_CASE_STORE_BYTES),
+    });
+    if (Object.keys(root).some(key => !['version', 'exportedAt', 'cases'].includes(key))) {
+        throw new TypeError('Case editing requires an ordinary Case export, not a response packet or an envelope with additional fields.');
+    }
+    if (!CLI_CASE_PACK_INPUT_CASE_VERSIONS.some(version => version === root.version) || !Array.isArray(root.cases)) {
+        throw new TypeError(`Case editing reads exact schemas ${CLI_CASE_PACK_INPUT_CASE_VERSIONS.join(', ')} and writes schema ${CASE_SCHEMA_VERSION}. Re-export other supported historical formats through the ordinary import workflow first.`);
+    }
+    if (Object.hasOwn(root, 'exportedAt') && !normalizeExplicitIsoTimestamp(root.exportedAt)) {
+        throw new TypeError('The Case export time is invalid.');
+    }
+    const cases = normalizeCaseStore(root).cases;
+    const projected = canonicalCaseExportProjection(cases, root.version);
+    const byId = new Map(projected.map(record => [record.id, record]));
+    const seen = new Set();
+    if (cases.length !== root.cases.length || root.cases.some(value => {
+        if (!value || typeof value !== 'object' || typeof value.id !== 'string' || seen.has(value.id))
+            return true;
+        seen.add(value.id);
+        return canonicalArtifactJsonV2(value) !== canonicalArtifactJsonV2(byId.get(value.id));
+    }))
+        throw new TypeError('The Case file would lose, repair or truncate retained data during normalisation. Nothing was changed.');
+    if (new TextEncoder().encode(serializeCaseStore(cases)).byteLength > MAX_CASE_STORE_BYTES) {
+        throw new TypeError('The Case file exceeds the canonical store byte budget. Select fewer Cases; no retained evidence was pruned.');
+    }
+    return cases;
+}

package/packages/cases/case-migration-model.mjs

@@ -1,13 +1,11 @@
-import { CASE_DISPOSITIONS, CASE_IMPORT_VERSIONS, CASE_SCHEMA_VERSION, CASE_SOURCES, CASE_STATUSES, DEFAULT_DISPOSITION, DEFAULT_SOURCE, DEFAULT_STATUS, MAX_CASES, MAX_NOTES_PER_CASE, deterministicId, caseTimestampOrNull, normalizeCase, normalizeDomain, normalizeEvidenceHistory, normalizeNotes, normalizeReviewReasonCode, normalizeTags, objectRecord, safeId, } from "./case-record-model.mjs";
-import { CASE_REPORT_SCHEMA, PUBLIC_CASE_SCHEMA_VERSION, caseReportVersionMatchesCase, CLI_CASE_PACK_CURRENT_REDACTION_KEYS, CLI_CASE_PACK_INTEGRITY_KEYS, CLI_CASE_PACK_LIMITATIONS, CLI_CASE_PACK_PACKET_KEYS, CLI_CASE_PACK_PUBLIC_REPORT_KEYS, CLI_CASE_PACK_REPORT_KEYS, CLI_CASE_PACK_ROOT_KEYS, CLI_CASE_PACK_SCHEMA, CLI_CASE_PACK_VERSION, } from "../contracts/case-portability.mjs";
+import { CASE_IMPORT_VERSIONS, CASE_SCHEMA_VERSION, DEFAULT_DISPOSITION, DEFAULT_SOURCE, DEFAULT_STATUS, MAX_CASES, MAX_NOTES_PER_CASE, deterministicId, caseTimestampOrNull, normalizeCase, normalizeDomain, normalizeCaseObjective, normalizeEvidenceHistory, normalizeNotes, normalizeReviewReasonCode, normalizeTags, objectRecord, safeId, isValidDisposition, isValidSource, isValidStatus, } from "./case-record-model.mjs";
+import { CASE_REPORT_SCHEMA, PUBLIC_CASE_SCHEMA_VERSION, PUBLISHED_V2_3_CASE_SCHEMA_VERSION, INCIDENT_CASE_SCHEMA_VERSION, caseReportVersionMatchesCase, CLI_CASE_PACK_CURRENT_REDACTION_KEYS, CLI_CASE_PACK_INTEGRITY_KEYS, CLI_CASE_PACK_LIMITATIONS, CLI_CASE_PACK_PACKET_KEYS, CLI_CASE_PACK_PUBLIC_REPORT_KEYS, CLI_CASE_PACK_REPORT_KEYS, CLI_CASE_PACK_ROOT_KEYS, CLI_CASE_PACK_SCHEMA, CLI_CASE_PACK_VERSION, } from "../contracts/case-portability.mjs";
 import { canonicalArtifactJsonV2 } from "../evidence/artifact-integrity.mjs";
+import { readCaseAttachments, mergeCaseAttachments } from "./case-attachment-model.mjs";
 import { assertBoundedJsonStructure } from "../../lib/bounded-json.mjs";
 import { inspectCaseBrandProfileIds, unionCaseBrandProfileIds, } from "./case-brand-profile-references.mjs";
 import { caseInvestigationBranchReferences, mergeCaseInvestigationBranches, normalizeCaseInvestigationBranches, } from "./case-investigation-branch-model.mjs";
-import { buildCaseClosureLinkContext, mergeCaseActions, mergeCaseAssertions, mergeCaseClosureHistories, mergeCaseDecisions, mergeCaseEvidencePins, mergeCaseManualTrail, mergeCaseObservedEffectHistories, mergeCaseSightings, normalizeCaseActions, normalizeCaseAssertions, normalizeCaseClosureHistory, normalizeCaseDecisions, normalizeCaseEvidencePins, normalizeCaseManualTrail, normalizeCaseObservedEffectHistory, normalizeCaseSightings, } from "./case-response-model.mjs";
-const STATUS_VALUES = new Set(CASE_STATUSES.map((item) => item.value));
-const DISPOSITION_VALUES = new Set(CASE_DISPOSITIONS.map((item) => item.value));
-const SOURCE_VALUES = new Set(CASE_SOURCES.map((item) => item.value));
+import { buildCaseClosureLinkContext, mergeCaseActions, mergeCaseClosureHistories, mergeCaseObservedEffectHistories, MAX_CASE_ASSERTIONS, MAX_CASE_DECISIONS, MAX_CASE_EVIDENCE_PINS, MAX_CASE_MANUAL_TRAIL_EVENTS, MAX_CASE_SIGHTINGS, normalizeCaseActions, normalizeCaseAssertions, normalizeCaseClosureHistory, normalizeCaseDecisions, normalizeCaseEvidencePins, normalizeCaseManualTrail, normalizeCaseObservedEffectHistory, normalizeCaseSightings, } from "./case-response-model.mjs";
 export const MAX_CASE_INPUT_RECORDS = 2_000;
 function compareCodeUnits(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
@@ -35,8 +33,8 @@ function assignUniqueIds(cases) {
 }
 /**
  * Recovers a clean, bounded store from the current versioned envelope or an
- * internal bare array, drops malformed records, keeps a single
- * case per domain (most recently updated wins), caps to MAX_CASES by recency,
+ * internal bare array, drops malformed records, preserves distinct current
+ * Case identities, caps to MAX_CASES by recency,
  * and guarantees globally unique safe ids. Retired, future, accessor-bearing,
  * sparse, or otherwise non-JSON envelopes fail before normalisation.
  * @param {unknown} raw
@@ -51,46 +49,64 @@ export function normalizeCaseStore(raw) {
             throw new TypeError(`Unversioned Case stores are retired. Export or reset them explicitly before using Case schema ${CASE_SCHEMA_VERSION}; no data was changed.`);
         }
         if (!CASE_IMPORT_VERSIONS.includes(sourceVersion) && sourceVersion < CASE_SCHEMA_VERSION) {
-            throw new TypeError(`Case schema ${sourceVersion} is not part of the supported compatibility boundary. Exact published schemas 12 and 13 migrate to schema ${CASE_SCHEMA_VERSION}; no data was changed.`);
+            throw new TypeError(`Case schema ${sourceVersion} is not part of the supported compatibility boundary. Exact published schemas ${CASE_IMPORT_VERSIONS.filter((version) => version < CASE_SCHEMA_VERSION).join(', ')} migrate to schema ${CASE_SCHEMA_VERSION}; no data was changed.`);
         }
         if (sourceVersion > CASE_SCHEMA_VERSION) {
             throw new TypeError(`Case schema ${sourceVersion} is newer than the supported schema ${CASE_SCHEMA_VERSION}; no data was changed.`);
         }
-        if (sourceVersion === CASE_SCHEMA_VERSION) {
-            assertCurrentCaseShape(raw);
+        if (sourceVersion >= PUBLISHED_V2_3_CASE_SCHEMA_VERSION) {
+            assertModernCaseShape(raw, sourceVersion);
         }
     }
-    const byDomain = new Map();
+    const byIdentity = new Map();
     for (const item of boundedCaseList(raw).items) {
         const normalized = normalizeCase(item, undefined, fallback, sourceVersion ?? CASE_SCHEMA_VERSION);
         if (!normalized)
             continue;
-        const existing = byDomain.get(normalized.domain);
+        // Published domain-centred stores retain their original recovery rule.
+        // Current incidents share a domain without sharing analyst decisions.
+        const key = sourceVersion !== null && sourceVersion < INCIDENT_CASE_SCHEMA_VERSION
+            ? normalized.domain : `${normalized.domain}\u0000${normalized.id}`;
+        const existing = byIdentity.get(key);
         if (!existing || Date.parse(normalized.updatedAt) >= Date.parse(existing.updatedAt)) {
-            byDomain.set(normalized.domain, normalized);
+            byIdentity.set(key, normalized);
         }
     }
-    const cases = [...byDomain.values()]
+    const cases = [...byIdentity.values()]
         .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))
         .slice(0, MAX_CASES);
     assignUniqueIds(cases);
     return { version: CASE_SCHEMA_VERSION, cases };
 }
-function assertCurrentCaseShape(raw) {
+function assertModernCaseShape(raw, sourceVersion) {
     for (const item of boundedCaseList(raw).items) {
         const itemRecord = objectRecord(item);
+        if (sourceVersion < INCIDENT_CASE_SCHEMA_VERSION && Object.hasOwn(itemRecord, 'attachments')) {
+            throw new TypeError('Retained file references require the current Case schema; no data was changed.');
+        }
         const evidenceHistory = itemRecord.evidenceHistory;
         for (const snapshot of Array.isArray(evidenceHistory) ? evidenceHistory : []) {
             const record = objectRecord(snapshot);
             if (Object.keys(record).length > 0 && !Object.hasOwn(record, 'inputHostname')) {
-                throw new TypeError(`Case schema ${CASE_SCHEMA_VERSION} evidence snapshots must declare their exact submitted hostname, including null; unreleased local Case checkpoints are not interpreted as the v2 format and no data was changed.`);
+                throw new TypeError(`Case schema ${sourceVersion} evidence snapshots must declare their exact submitted hostname, including null; no data was changed.`);
             }
         }
         const actions = itemRecord.actions;
         for (const action of Array.isArray(actions) ? actions : []) {
             const record = objectRecord(action);
             if (Object.keys(record).length > 0 && !Object.hasOwn(record, 'routeObservedAt')) {
-                throw new TypeError(`Case schema ${CASE_SCHEMA_VERSION} response actions must declare their route observation time, including null; unreleased local Case checkpoints are not interpreted as the current format and no data was changed.`);
+                throw new TypeError(`Case schema ${sourceVersion} response actions must declare their route observation time, including null; no data was changed.`);
+            }
+            if (Object.keys(record).length > 0 && !Object.hasOwn(record, 'routeReviewAfter')) {
+                throw new TypeError(`Case schema ${sourceVersion} response actions must declare their route review deadline, including null; no data was changed.`);
+            }
+        }
+        const decisions = itemRecord.decisions;
+        for (const decision of Array.isArray(decisions) ? decisions : []) {
+            const record = objectRecord(decision);
+            if (Object.keys(record).length > 0
+                && (!Object.hasOwn(record, 'confidence') || !Object.hasOwn(record, 'confidenceBasis'))) {
+                throw new TypeError(`Case schema ${sourceVersion} analyst decisions must declare confidence and its basis; no data was changed.`);
             }
         }
     }
@@ -140,9 +156,6 @@ function boundedCaseList(raw) {
  * @param {string} [nowIso]
  * @returns {CaseRecord}
  */
-function importScalar(value, valid) {
-    return typeof value === 'string' && valid.has(value) ? value : undefined;
-}
 /**
  * Validates one imported record into a patch. Unlike normalizeCase, absent or
  * invalid scalar fields stay `undefined` (never defaulted) and a missing/invalid
@@ -163,7 +176,7 @@ function extractImportPatch(raw, importedVersion) {
         || null;
     const normalizedFallback = importFallback || '1970-01-01T00:00:00.000Z';
     const timestampOptions = {
-        legacyTimestamps: importedVersion < CASE_SCHEMA_VERSION,
+        legacyTimestamps: importedVersion < PUBLISHED_V2_3_CASE_SCHEMA_VERSION,
         sourceVersion: importedVersion,
     };
     const rawEvidence = Array.isArray(record.evidenceHistory) ? record.evidenceHistory : [];
@@ -174,6 +187,8 @@ function extractImportPatch(raw, importedVersion) {
     const pinIds = new Set(evidencePins.map((item) => item.id));
     const actions = normalizeCaseActions(record.actions, normalizedFallback, { ...timestampOptions, validEvidencePinIds: pinIds });
     const assertions = normalizeCaseAssertions(record.assertions, normalizedFallback, pinIds, timestampOptions);
+    const decisions = normalizeCaseDecisions(record.decisions, normalizedFallback, pinIds, timestampOptions);
+    const manualTrail = normalizeCaseManualTrail(record.manualTrail, normalizedFallback, timestampOptions);
     const sightings = normalizeCaseSightings(record.sightings, normalizedFallback, pinIds, timestampOptions);
     const observedEffects = normalizeCaseObservedEffectHistory(importedVersion >= 13 ? record.observedEffects : undefined, normalizedFallback, pinIds, new Set(sightings.map((item) => item.id)), timestampOptions);
     const closures = normalizeCaseClosureHistory(importedVersion >= 13 ? record.closures : undefined, normalizedFallback, new Set(observedEffects.reviews.map((item) => item.id)), new Set(actions.map((item) => item.id)), timestampOptions, buildCaseClosureLinkContext(observedEffects, actions));
@@ -181,17 +196,27 @@ function extractImportPatch(raw, importedVersion) {
     const brandProfileReferences = importedVersion >= 12
         ? inspectCaseBrandProfileIds(record.brandProfileIds)
         : { ids: [], omitted: 0 };
+    const authoredHistoryOmitted = [
+        [record.evidencePins, evidencePins],
+        [record.decisions, decisions],
+        [record.assertions, assertions],
+        [record.manualTrail, manualTrail],
+        [record.sightings, sightings],
+    ].reduce((total, [candidates, retained]) => total
+        + Math.max(0, (Array.isArray(candidates) ? candidates.length : 0) - retained.length), 0);
     return {
         domain,
         rawId: typeof record.id === 'string' ? record.id : null,
-        status: importScalar(record.status, STATUS_VALUES),
-        disposition: importScalar(record.disposition, DISPOSITION_VALUES),
+        title: typeof record.title === 'string' && importedVersion >= INCIDENT_CASE_SCHEMA_VERSION ? normalizeCaseObjective(record.title) : undefined,
+        status: isValidStatus(record.status) ? record.status : undefined,
+        disposition: isValidDisposition(record.disposition) ? record.disposition : undefined,
         reviewReasonCode: Object.hasOwn(record, 'reviewReasonCode')
             ? normalizeReviewReasonCode(record.reviewReasonCode)
             : undefined,
         brandProfileIds: brandProfileReferences.ids,
         brandProfileReferencesOmitted: brandProfileReferences.omitted,
-        source: importScalar(record.source, SOURCE_VALUES),
+        authoredHistoryOmitted,
+        source: isValidSource(record.source) ? record.source : undefined,
         evidenceHistory: normalizeEvidenceHistory(rawEvidence, {
             source: 'import',
             fallback: importFallback,
@@ -199,16 +224,17 @@ function extractImportPatch(raw, importedVersion) {
             caseDomain: domain,
         }),
         evidencePins,
-        decisions: normalizeCaseDecisions(record.decisions, normalizedFallback, pinIds, timestampOptions),
+        decisions,
         actions,
         assertions,
-        manualTrail: normalizeCaseManualTrail(record.manualTrail, normalizedFallback, timestampOptions),
+        manualTrail,
         sightings,
         observedEffects,
         closures,
         branches: importedVersion >= 11
             ? normalizeCaseInvestigationBranches(record.branches, normalizedFallback, branchReferences, timestampOptions)
             : [],
+        attachments: importedVersion >= INCIDENT_CASE_SCHEMA_VERSION ? readCaseAttachments(record.attachments) : undefined,
         tags: normalizeTags(record.tags),
         // Imported notes fall back only to the imported record's own timestamps
         // (never "now"), so a timestamp-less note gets a stable, deterministic time
@@ -229,6 +255,22 @@ function unionNotes(a, b) {
     const notes = [...byId.values()].sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt));
     return notes.slice(Math.max(0, notes.length - MAX_NOTES_PER_CASE));
 }
+function retainLocalAuthoredRecords(local, imported, maximum) {
+    const records = [...local];
+    const retainedIds = new Set(records.map((item) => item.id));
+    let omitted = 0;
+    for (const item of imported) {
+        if (retainedIds.has(item.id))
+            continue;
+        if (records.length >= maximum) {
+            omitted += 1;
+            continue;
+        }
+        records.push(item);
+        retainedIds.add(item.id);
+    }
+    return { records, omitted };
+}
 // Additive, deduplicated union of two evidence histories. Identical material
 // collapses (earliest firstCapturedAt, latest capturedAt), distinct snapshots
 // are retained subject to the per-case bound, and an older import can never
@@ -241,6 +283,7 @@ function caseFromPatch(patch, now) {
     return {
         id: '', // assigned by mergeCases so it can guarantee uniqueness against locals
         domain: patch.domain,
+        title: patch.title ?? '',
         status: patch.status ?? DEFAULT_STATUS,
         disposition: patch.disposition ?? DEFAULT_DISPOSITION,
         reviewReasonCode: patch.reviewReasonCode ?? null,
@@ -258,6 +301,7 @@ function caseFromPatch(patch, now) {
         observedEffects: patch.observedEffects,
         closures: patch.closures,
         branches: patch.branches,
+        ...(patch.attachments === undefined ? {} : { attachments: patch.attachments }),
         createdAt: patch.createdAt || patch.updatedAt || now,
         updatedAt: patch.updatedAt || patch.createdAt || now,
     };
@@ -274,18 +318,33 @@ function caseFromPatch(patch, now) {
 function applyImportPatch(local, patch) {
     const importNewer = patch.updatedAt !== null && Date.parse(patch.updatedAt) > Date.parse(local.updatedAt);
     const fallback = patch.updatedAt || local.updatedAt;
-    const evidencePins = mergeCaseEvidencePins(local.evidencePins, patch.evidencePins, fallback);
+    const pinSelection = retainLocalAuthoredRecords(local.evidencePins, patch.evidencePins, MAX_CASE_EVIDENCE_PINS);
+    const evidencePins = normalizeCaseEvidencePins(pinSelection.records, fallback);
     const pinIds = new Set(evidencePins.map((item) => item.id));
     const actions = mergeCaseActions(local.actions, patch.actions, fallback, pinIds);
-    const assertions = mergeCaseAssertions(local.assertions, patch.assertions, fallback, pinIds);
+    const assertionSelection = retainLocalAuthoredRecords(local.assertions, patch.assertions, MAX_CASE_ASSERTIONS);
+    const assertions = normalizeCaseAssertions(assertionSelection.records, fallback, pinIds);
     const branchReferences = caseInvestigationBranchReferences({ evidencePins, actions, assertions });
-    const sightings = mergeCaseSightings(local.sightings, patch.sightings, fallback, pinIds);
+    const sightingSelection = retainLocalAuthoredRecords(local.sightings, patch.sightings, MAX_CASE_SIGHTINGS);
+    const sightings = normalizeCaseSightings(sightingSelection.records, fallback, pinIds);
     const sightingIds = new Set(sightings.map((item) => item.id));
     const observedEffects = mergeCaseObservedEffectHistories(local.observedEffects, patch.observedEffects, fallback, pinIds, sightingIds);
     const closures = mergeCaseClosureHistories(local.closures, patch.closures, fallback, new Set(observedEffects.reviews.map((item) => item.id)), new Set(actions.map((item) => item.id)), buildCaseClosureLinkContext(observedEffects, actions));
     const brandProfileReferences = unionCaseBrandProfileIds(local.brandProfileIds, patch.brandProfileIds);
+    const decisionSelection = retainLocalAuthoredRecords(local.decisions, patch.decisions, MAX_CASE_DECISIONS);
+    const decisions = normalizeCaseDecisions(decisionSelection.records, fallback, pinIds);
+    const trailSelection = retainLocalAuthoredRecords(local.manualTrail, patch.manualTrail, MAX_CASE_MANUAL_TRAIL_EVENTS);
+    const manualTrail = normalizeCaseManualTrail(trailSelection.records, fallback);
+    const attachments = mergeCaseAttachments(local.attachments, patch.attachments);
+    const authoredHistoryOmitted = patch.authoredHistoryOmitted
+        + pinSelection.omitted
+        + decisionSelection.omitted
+        + assertionSelection.omitted
+        + trailSelection.omitted
+        + sightingSelection.omitted;
     return { record: {
             ...local,
+            title: patch.title !== undefined && importNewer ? patch.title : local.title ?? '',
             status: patch.status !== undefined && importNewer ? patch.status : local.status,
             disposition: patch.disposition !== undefined && importNewer ? patch.disposition : local.disposition,
             reviewReasonCode: patch.reviewReasonCode !== undefined && importNewer ? patch.reviewReasonCode : local.reviewReasonCode ?? null,
@@ -293,19 +352,20 @@ function applyImportPatch(local, patch) {
             source: patch.source !== undefined && importNewer ? patch.source : local.source,
             evidenceHistory: mergeEvidenceHistories(local.evidenceHistory, patch.evidenceHistory, local.domain),
             evidencePins,
-            decisions: mergeCaseDecisions(local.decisions, patch.decisions, fallback, pinIds),
+            decisions,
             actions,
             assertions,
-            manualTrail: mergeCaseManualTrail(local.manualTrail, patch.manualTrail, fallback),
+            manualTrail,
             sightings,
             observedEffects,
             closures,
             branches: mergeCaseInvestigationBranches(local.branches ?? [], patch.branches, fallback, branchReferences),
+            ...(attachments === undefined ? {} : { attachments }),
             tags: normalizeTags([...local.tags, ...patch.tags]),
             notes: unionNotes(local.notes, patch.notes),
             createdAt: patch.createdAt && Date.parse(patch.createdAt) < Date.parse(local.createdAt) ? patch.createdAt : local.createdAt,
             updatedAt: importNewer ? (patch.updatedAt ?? local.updatedAt) : local.updatedAt,
-        }, brandProfileReferencesOmitted: brandProfileReferences.omitted };
+        }, brandProfileReferencesOmitted: brandProfileReferences.omitted, authoredHistoryOmitted };
 }
 function pickFreeId(preferred, domain, used) {
     const wanted = safeId(preferred);
@@ -411,14 +471,14 @@ function caseCollectionImportEnvelope(importedRaw) {
 }
 /**
  * Merges an imported (already parsed) value into the local cases. Predictable
- * and idempotent: unknown records are skipped, existing domains merge without
+ * and idempotent: unknown records are skipped, matching Case identities merge without
  * losing newer local decisions, and new ones are added until the store bound is
  * reached. An imported envelope that declares a schema version newer than we
  * support is rejected up front (before any local data is touched) rather than
  * reinterpreted.
  * @param {CaseRecord[]} localCases
  * @param {unknown} importedRaw
- * @returns {{ cases: CaseRecord[], added: number, updated: number, skipped: number, brandProfileReferencesOmitted: number }}
+ * @returns {{ cases: CaseRecord[], added: number, updated: number, skipped: number, brandProfileReferencesOmitted: number, authoredHistoryOmitted: number }}
  */
 export function mergeCases(localCases, importedRaw) {
     assertBoundedJsonStructure(importedRaw, 'Case import', CASE_INPUT_JSON_LIMITS);
@@ -426,7 +486,7 @@ export function mergeCases(localCases, importedRaw) {
     const importedVersion = parseStoreVersion(importedEnvelope);
     if (importedVersion !== null && Number.isSafeInteger(importedVersion) && importedVersion < CASE_SCHEMA_VERSION
         && !CASE_IMPORT_VERSIONS.includes(importedVersion)) {
-        throw new Error(`Case schema ${importedVersion} is not part of the supported compatibility boundary. Exact published schemas 12 and 13 migrate to schema ${CASE_SCHEMA_VERSION}; no data was changed.`);
+        throw new Error(`Case schema ${importedVersion} is not part of the supported compatibility boundary. Exact published schemas ${CASE_IMPORT_VERSIONS.filter((version) => version < CASE_SCHEMA_VERSION).join(', ')} migrate to schema ${CASE_SCHEMA_VERSION}; no data was changed.`);
     }
     if (importedVersion !== null && Number.isSafeInteger(importedVersion) && importedVersion > CASE_SCHEMA_VERSION) {
         throw new Error(`Case schema ${importedVersion} is newer than the supported schema ${CASE_SCHEMA_VERSION}; no data was changed.`);
@@ -435,37 +495,59 @@ export function mergeCases(localCases, importedRaw) {
         || !Array.isArray(importedEnvelope.cases)) {
         throw new Error(`Expected a well-formed WHOISleuth Case export using schema ${CASE_SCHEMA_VERSION}; no data was changed.`);
     }
-    if (importedVersion === CASE_SCHEMA_VERSION)
-        assertCurrentCaseShape(importedEnvelope);
+    if (importedVersion !== null && importedVersion >= PUBLISHED_V2_3_CASE_SCHEMA_VERSION)
+        assertModernCaseShape(importedEnvelope, importedVersion);
     const local = normalizeCaseStore(localCases).cases;
     const supportedImportedVersion = importedVersion ?? 0;
-    const byDomain = new Map(local.map((item) => [item.domain, item]));
+    const byId = new Map(local.map((item) => [item.id, item]));
     const usedIds = new Set(local.map((item) => item.id));
     let added = 0;
     let updated = 0;
     const imported = boundedCaseList(importedEnvelope);
     let skipped = imported.omitted;
     let brandProfileReferencesOmitted = 0;
+    let authoredHistoryOmitted = 0;
     const fallback = new Date(0).toISOString();
+    const importedIds = new Set();
     for (const item of imported.items) {
         const patch = extractImportPatch(item, supportedImportedVersion);
         if (!patch) {
             skipped += 1;
             continue;
         }
-        const existing = byDomain.get(patch.domain);
+        const importedId = safeId(patch.rawId);
+        if (supportedImportedVersion >= INCIDENT_CASE_SCHEMA_VERSION && importedId) {
+            if (importedIds.has(importedId))
+                throw new Error('Incident Case imports cannot repeat a declared Case ID. No data was changed.');
+            importedIds.add(importedId);
+        }
+        let existing = importedId ? byId.get(importedId) : undefined;
+        if (existing && existing.domain !== patch.domain) {
+            if (supportedImportedVersion >= INCIDENT_CASE_SCHEMA_VERSION)
+                throw new Error('An imported Case ID belongs to a different domain in this workspace. No data was changed.');
+            existing = undefined;
+        }
+        if (!existing && (supportedImportedVersion < INCIDENT_CASE_SCHEMA_VERSION || !importedId)) {
+            const matchingDomain = [...byId.values()].filter(record => record.domain === patch.domain);
+            if (matchingDomain.length > 1) {
+                throw new Error(`The imported record for ${patch.domain} has no matching Case identity and several incidents exist. Import it into a separate workspace to review it without merging incidents; no data was changed.`);
+            }
+            existing = matchingDomain[0];
+        }
         if (existing) {
             const merged = applyImportPatch(existing, patch);
-            byDomain.set(patch.domain, merged.record);
+            byId.set(existing.id, merged.record);
             brandProfileReferencesOmitted += patch.brandProfileReferencesOmitted + merged.brandProfileReferencesOmitted;
+            authoredHistoryOmitted += merged.authoredHistoryOmitted;
             updated += 1;
         }
-        else if (byDomain.size < MAX_CASES) {
+        else if (byId.size < MAX_CASES) {
             const record = caseFromPatch(patch, fallback);
             record.id = pickFreeId(patch.rawId, patch.domain, usedIds);
             usedIds.add(record.id);
-            byDomain.set(patch.domain, record);
+            byId.set(record.id, record);
             brandProfileReferencesOmitted += patch.brandProfileReferencesOmitted;
+            authoredHistoryOmitted += patch.authoredHistoryOmitted;
             added += 1;
         }
         else {
@@ -473,10 +555,11 @@ export function mergeCases(localCases, importedRaw) {
         }
     }
     return {
-        cases: normalizeCaseStore([...byDomain.values()]).cases,
+        cases: normalizeCaseStore([...byId.values()]).cases,
         added,
         updated,
         skipped,
         brandProfileReferencesOmitted,
+        authoredHistoryOmitted,
     };
 }

package/packages/cases/case-model.mjs

@@ -3,3 +3,4 @@
 export * from "./case-record-model.mjs";
 export * from "./case-migration-model.mjs";
 export * from "./case-storage-model.mjs";
+export * from "./case-selection.mjs";

package/packages/cases/case-recheck-model.mjs

@@ -0,0 +1,91 @@
+import { isValidAsciiHostname } from "../../lib/hostname.mjs";
+import { INCIDENT_CASE_SCHEMA_VERSION, MAX_RESPONSE_RATIONALE_LENGTH } from "../contracts/case-portability.mjs";
+import { enumeration, exact, text } from "../evidence/artifact-structure.mjs";
+export const CASE_RECHECK_CONDITIONS = Object.freeze({ unknown: 'Not established', comparable: 'Comparable for this question', different: 'Different conditions' });
+function reference(value, label) {
+    const id = text(value, label, 64);
+    if (!/^[A-Za-z0-9_-]+$/u.test(id))
+        throw new TypeError(`${label} is invalid.`);
+    return id;
+}
+function contextFields(item) {
+    const targetHostname = text(item.targetHostname, 'Recheck target hostname', 253);
+    if (targetHostname !== targetHostname.toLowerCase() || !isValidAsciiHostname(targetHostname)) {
+        throw new TypeError('Use one normalised hostname for the recheck target, without a path or query.');
+    }
+    const conditions = text(item.conditions, 'Recheck comparison conditions', MAX_RESPONSE_RATIONALE_LENGTH);
+    if (!conditions.trim())
+        throw new TypeError('Describe the conditions needed to compare the observations.');
+    return Object.freeze({ targetHostname, conditions,
+        baselinePinId: item.baselinePinId === null ? null : reference(item.baselinePinId, 'Recheck baseline pin') });
+}
+/** Optional current-format context; historical records have no invented question. */
+export function readCaseRecheckContext(value, sourceVersion) {
+    if (value === undefined)
+        return undefined;
+    if (sourceVersion != null && sourceVersion < INCIDENT_CASE_SCHEMA_VERSION)
+        throw new TypeError('This Case format cannot contain structured recheck questions.');
+    return contextFields(exact(value, ['targetHostname', 'baselinePinId', 'conditions'], 'Recheck question context'));
+}
+export function readCaseRecheckAnswerContext(value, sourceVersion) {
+    if (value === undefined)
+        return undefined;
+    if (sourceVersion != null && sourceVersion < INCIDENT_CASE_SCHEMA_VERSION)
+        throw new TypeError('This Case format cannot contain structured recheck answers.');
+    const item = exact(value, ['targetHostname', 'baselinePinId', 'conditions', 'questionId', 'question', 'conditionsMatch'], 'Recheck answer context');
+    const question = text(item.question, 'Recheck question', MAX_RESPONSE_RATIONALE_LENGTH);
+    if (!question.trim())
+        throw new TypeError('A recheck answer requires its original question.');
+    return Object.freeze({ ...contextFields(item), questionId: reference(item.questionId, 'Recheck question ID'),
+        question,
+        conditionsMatch: enumeration(item.conditionsMatch, Object.keys(CASE_RECHECK_CONDITIONS), 'Recheck condition comparison') });
+}
+export function caseRecheckQuestions(assertions) {
+    return assertions.filter(item => item.kind === 'next_step' && item.recheck && item.state === 'open');
+}
+export function caseRecheckAnswerContext(question, conditionsMatch) {
+    if (question.kind !== 'next_step' || !question.recheck)
+        throw new TypeError('Select a saved recheck question.');
+    return readCaseRecheckAnswerContext({ ...question.recheck, questionId: question.id, question: question.statement, conditionsMatch });
+}
+/** A saved answer is a snapshot, not a live reference to an editable plan. */
+export function assertCurrentRecheckQuestion(answer, assertions) {
+    const question = caseRecheckQuestions(assertions).find(item => item.id === answer.questionId);
+    if (!question || JSON.stringify(caseRecheckAnswerContext(question, answer.conditionsMatch)) !== JSON.stringify(answer)) {
+        throw new Error('The recheck question changed or was resolved. Refresh and review its current conditions before saving this answer.');
+    }
+}
+export function caseRecheckComparisonWarnings(context, pins, current) {
+    const warnings = [];
+    if (context.conditionsMatch !== 'comparable')
+        warnings.push(context.conditionsMatch === 'different'
+            ? 'The comparison conditions differ.' : 'Comparable conditions have not been confirmed.');
+    const baseline = pins.find(pin => pin.id === context.baselinePinId);
+    if (context.baselinePinId && !baseline)
+        warnings.push('The baseline evidence is no longer available.');
+    if (current) {
+        if (current.observationHostname !== context.targetHostname)
+            warnings.push('The current evidence concerns a different or unknown hostname.');
+        if (current.completeness !== 'complete' || current.truncated || current.sourceState !== 'complete' && current.sourceState !== 'success' && current.sourceState !== 'reviewed' && current.sourceState !== 'not_found')
+            warnings.push('The current source does not establish a complete observation.');
+        if (baseline) {
+            if (baseline.id === current.id || !baseline.observedAt || !current.observedAt || Date.parse(current.observedAt) <= Date.parse(baseline.observedAt))
+                warnings.push('A later source observation is needed; reviewing the baseline again is not a recheck.');
+            if (baseline.observationHostname && baseline.observationHostname !== context.targetHostname)
+                warnings.push('The baseline concerns a different hostname.');
+            if (baseline.field && current.field !== baseline.field || baseline.source !== current.source)
+                warnings.push('The observations use different fields or sources.');
+        }
+    }
+    return warnings;
+}
+export function assertRecheckNonReproduction(state, context, completeness, pins, current, observedAt) {
+    if (state !== 'not_reproduced')
+        return;
+    const warnings = caseRecheckComparisonWarnings(context, pins, current);
+    const baseline = pins.find(pin => pin.id === context.baselinePinId);
+    if (!current && baseline && (!baseline.observedAt || !observedAt || !Number.isFinite(Date.parse(observedAt)) || Date.parse(observedAt) <= Date.parse(baseline.observedAt)))
+        warnings.push('A later independent observation is needed.');
+    if (completeness !== 'complete' || warnings.length)
+        throw new Error('Not reproduced requires a complete observation under comparable conditions. Record unavailable or describe the limited observation instead.');
+}

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

@@ -1,30 +1,15 @@
 import { ANALYST_REVIEW_REASONS } from "../../lib/analyst-taxonomy.mjs";
 import { CASE_IMPORT_VERSIONS, CASE_SCHEMA_VERSION, PUBLIC_CASE_SCHEMA_VERSION, MAX_CASE_BRAND_PROFILE_ID_CANDIDATES, MAX_CASE_BRAND_PROFILE_IDS, MAX_CASE_IMPORT_BYTES, MAX_CASE_STORE_BYTES, MAX_CASES, MAX_DOMAIN_LENGTH, MAX_EVIDENCE_CHANGES, MAX_EVIDENCE_DETAIL_LENGTH, MAX_EVIDENCE_FACTORS, MAX_EVIDENCE_MUTATIONS, MAX_EVIDENCE_NAMESERVERS, MAX_EVIDENCE_SNAPSHOTS_PER_CASE, MAX_EVIDENCE_STRING_LENGTH, MAX_EVIDENCE_TITLE_LENGTH, MAX_NOTE_LENGTH, MAX_NOTES_PER_CASE, MAX_TAG_LENGTH, MAX_TAGS_PER_CASE, } from "../contracts/case-portability.mjs";
+import { CASE_DISPOSITIONS, CASE_STATUSES, DEFAULT_DISPOSITION, DEFAULT_STATUS, } from "./case-record-decisions.mjs";
 export { CASE_IMPORT_VERSIONS, CASE_SCHEMA_VERSION, PUBLIC_CASE_SCHEMA_VERSION, MAX_CASE_BRAND_PROFILE_ID_CANDIDATES, MAX_CASE_BRAND_PROFILE_IDS, MAX_CASE_IMPORT_BYTES, MAX_CASE_STORE_BYTES, MAX_CASES, MAX_DOMAIN_LENGTH, MAX_EVIDENCE_CHANGES, MAX_EVIDENCE_DETAIL_LENGTH, MAX_EVIDENCE_FACTORS, MAX_EVIDENCE_MUTATIONS, MAX_EVIDENCE_NAMESERVERS, MAX_EVIDENCE_SNAPSHOTS_PER_CASE, MAX_EVIDENCE_STRING_LENGTH, MAX_EVIDENCE_TITLE_LENGTH, MAX_NOTE_LENGTH, MAX_NOTES_PER_CASE, MAX_TAG_LENGTH, MAX_TAGS_PER_CASE, };
-export const CASE_STATUSES = [
-    { value: 'new', label: 'New' },
-    { value: 'reviewing', label: 'Reviewing' },
-    { value: 'monitoring', label: 'Monitoring' },
-    { value: 'escalated', label: 'Escalated' },
-    { value: 'resolved', label: 'Resolved' },
-];
-export const CASE_DISPOSITIONS = [
-    { value: 'unreviewed', label: 'Unreviewed' },
-    { value: 'suspicious', label: 'Suspicious' },
-    { value: 'confirmed_abuse', label: 'Confirmed abuse' },
-    { value: 'false_positive', label: 'False positive' },
-    { value: 'expected', label: 'Expected' },
-    { value: 'closed_no_action', label: 'Closed without action' },
-];
+export { CASE_DISPOSITIONS, CASE_STATUSES, DEFAULT_DISPOSITION, DEFAULT_STATUS, };
 export const CASE_REVIEW_REASONS = ANALYST_REVIEW_REASONS.map((item) => ({ ...item }));
-export const CASE_SOURCES = [
+export const CASE_SOURCES = Object.freeze([
     { value: 'lookup', label: 'Lookup' },
     { value: 'bulk', label: 'Bulk' },
     { value: 'monitor', label: 'Monitor' },
     { value: 'manual', label: 'Manual' },
     { value: 'unknown', label: 'Unknown' },
-];
-export const EVIDENCE_SOURCES = ['lookup', 'bulk', 'monitor', 'import', 'unknown'];
-export const DEFAULT_STATUS = 'new';
-export const DEFAULT_DISPOSITION = 'unreviewed';
+]);
+export const EVIDENCE_SOURCES = Object.freeze(['lookup', 'bulk', 'monitor', 'import', 'unknown']);
 export const DEFAULT_SOURCE = 'unknown';