@slicedearth/whoisleuth-cli 2.3.0 → 2.4.0

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

@@ -1,6 +1,7 @@
-import { CASE_IMPORT_VERSIONS, CASE_SCHEMA_VERSION, DEFAULT_DISPOSITION, DEFAULT_SOURCE, DEFAULT_STATUS, MAX_CASES, MAX_NOTES_PER_CASE, deterministicId, caseTimestampOrNull, normalizeCase, normalizeDomain, normalizeEvidenceHistory, normalizeNotes, normalizeReviewReasonCode, normalizeTags, objectRecord, safeId, isValidDisposition, isValidSource, isValidStatus, } 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";
@@ -32,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
@@ -53,44 +54,51 @@ export function normalizeCaseStore(raw) {
         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 ${CASE_SCHEMA_VERSION} response actions must declare their route review deadline, 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 review deadline, including null; no data was changed.`);
             }
         }
         const decisions = itemRecord.decisions;
@@ -98,7 +106,7 @@ function assertCurrentCaseShape(raw) {
             const record = objectRecord(decision);
             if (Object.keys(record).length > 0
                 && (!Object.hasOwn(record, 'confidence') || !Object.hasOwn(record, 'confidenceBasis'))) {
-                throw new TypeError(`Case schema ${CASE_SCHEMA_VERSION} analyst decisions must declare confidence and its basis; unreleased local Case checkpoints are not interpreted as the current format and no data was changed.`);
+                throw new TypeError(`Case schema ${sourceVersion} analyst decisions must declare confidence and its basis; no data was changed.`);
             }
         }
     }
@@ -168,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 : [];
@@ -199,6 +207,7 @@ function extractImportPatch(raw, importedVersion) {
     return {
         domain,
         rawId: typeof record.id === 'string' ? record.id : null,
+        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')
@@ -225,6 +234,7 @@ function extractImportPatch(raw, importedVersion) {
         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
@@ -273,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,
@@ -290,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,
     };
@@ -323,6 +335,7 @@ function applyImportPatch(local, patch) {
     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
@@ -331,6 +344,7 @@ function applyImportPatch(local, patch) {
         + 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,
@@ -346,6 +360,7 @@ function applyImportPatch(local, patch) {
             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,
@@ -456,7 +471,7 @@ 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
@@ -480,11 +495,11 @@ 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;
@@ -493,25 +508,44 @@ export function mergeCases(localCases, importedRaw) {
     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;
@@ -521,7 +555,7 @@ export function mergeCases(localCases, importedRaw) {
         }
     }
     return {
-        cases: normalizeCaseStore([...byDomain.values()]).cases,
+        cases: normalizeCaseStore([...byId.values()]).cases,
         added,
         updated,
         skipped,

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-core.mjs

@@ -1,8 +1,9 @@
 // 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 { PUBLISHED_V2_3_CASE_SCHEMA_VERSION } from "../contracts/case-portability.mjs";
 import { canonicalRegistrableDomain } from "../../lib/registrable-domain.mjs";
 // Forward-version policy (two distinct guarantees):
 //   - A locally-stored envelope that declares a version greater than this is
@@ -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,15 +1,20 @@
 // 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 { selectExistingCase } from "./case-selection.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 { PUBLISHED_V2_3_CASE_SCHEMA_VERSION, INCIDENT_CASE_SCHEMA_VERSION, MAX_CASE_OBJECTIVE_LENGTH } from "../contracts/case-portability.mjs";
+import { readCaseAttachments } from "./case-attachment-model.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 { 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: ';
@@ -23,18 +28,8 @@ 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)
+    const parsed = parseCredentialFreeHttpUrl(value, MAX_CASE_INCIDENT_URL_LENGTH);
+    if (!parsed)
         return null;
     const hostname = parsed.hostname.toLowerCase().replace(/\.$/u, '');
     const registrableDomain = canonicalRegistrableDomain(hostname);
@@ -142,7 +137,7 @@ export function normalizeCase(raw, existing, nowIso, 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,
+        legacyTimestamps: sourceVersion != null && sourceVersion < PUBLISHED_V2_3_CASE_SCHEMA_VERSION,
         ...(sourceVersion === undefined ? {} : { sourceVersion }),
     };
     const evidencePins = normalizeCaseEvidencePins(record.evidencePins, updatedAt, timestampOptions);
@@ -155,9 +150,11 @@ export function normalizeCase(raw, existing, nowIso, sourceVersion) {
     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 normalizedStatus = normalizeStatus(record.status);
     const branchReferences = caseInvestigationBranchReferences({ evidencePins, actions, assertions });
+    const attachments = readCaseAttachments(record.attachments);
     return {
         id: existing ? existing.id : safeId(record.id) || deterministicId(domain),
         domain,
+        title: sourceVersion != null && sourceVersion < INCIDENT_CASE_SCHEMA_VERSION ? '' : normalizeCaseObjective(record.title),
         status: caseStatusRequiresClosure(normalizedStatus)
             && closures.records.length === 0 && !closures.preV13HistoryUnavailable
             ? 'reviewing'
@@ -178,6 +175,7 @@ export function normalizeCase(raw, existing, nowIso, sourceVersion) {
         observedEffects,
         closures,
         branches: normalizeCaseInvestigationBranches(record.branches, updatedAt, branchReferences, timestampOptions),
+        ...(attachments === undefined ? {} : { attachments }),
         createdAt,
         updatedAt,
     };
@@ -213,6 +211,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,6 +226,7 @@ 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),
@@ -254,25 +259,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 +319,9 @@ export function updateCase(cases, id, patch, nowIso) {
     const current = cases[index];
     if (!current)
         throw new Error('That case no longer exists.');
+    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.');
+    }
     let notes = current.notes;
     if (patch.note !== undefined) {
         const body = normalizeNoteBody(patch.note);
@@ -352,6 +381,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 +398,7 @@ export function updateCase(cases, id, patch, nowIso) {
     }
     const record = {
         ...current,
+        title: patch.title === undefined ? current.title ?? '' : normalizeCaseObjective(patch.title),
         status: patch.closure !== undefined
             ? 'resolved'
             : patch.status !== undefined ? normalizeStatus(patch.status) : current.status,
@@ -394,8 +430,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 +458,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 +497,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 +512,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) {
@@ -505,6 +563,8 @@ export function recordCaseRecheckOutcome(cases, id, input, nowIso) {
     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,6 +576,7 @@ export function recordCaseRecheckOutcome(cases, id, input, nowIso) {
             sourceState: 'reviewed',
             observedAt: input.observedAt,
             collectionDepth: input.collectionDepth,
+            observationHostname: input.observationHostname,
             completeness: input.completeness,
             truncated: false,
             limitations: input.limitations,
@@ -534,6 +595,7 @@ export function recordCaseRecheckOutcome(cases, id, input, nowIso) {
             evidencePinId: comparisonPin.id,
             followUpAt: input.followUpAt,
             limitations: input.limitations,
+            ...(input.recheck ? { recheck: input.recheck } : {}),
         },
     }, now);
 }