@slicedearth/whoisleuth-cli 2.0.1 → 2.2.0

package/package.json

@@ -33,14 +33,14 @@
   "bugs": {
     "url": "https://github.com/slicedearth/whoisleuth/issues"
   },
-  "version": "2.0.1",
+  "version": "2.2.0",
   "dependencies": {
     "@peculiar/x509": "2.0.0",
     "maxmind": "5.0.7",
     "parse5": "8.0.1",
     "reflect-metadata": "0.2.2",
     "tldts": "7.4.11",
-    "undici": "8.10.0"
+    "undici": "8.10.1"
   },
   "files": [
     "bin/**/*.mjs",

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

@@ -413,6 +413,15 @@ export function latestCaseEvidence(record) {
     const history = record && Array.isArray(record.evidenceHistory) ? record.evidenceHistory : [];
     return history.at(-1) ?? null;
 }
+/**
+ * Returns the exact hostname from the latest retained observation when it is
+ * available. The registrable Case identity is the conservative fallback; an
+ * older hostname is never substituted for a newer observation with unknown
+ * hostname context.
+ */
+export function caseLookupTarget(record) {
+    return latestCaseEvidence(record)?.inputHostname || record.domain;
+}
 // ---------------------------------------------------------------------------
 // Material-change comparison (pure; no Svelte, DOM, or persistence access)
 // ---------------------------------------------------------------------------

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

@@ -1,5 +1,5 @@
 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, 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_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 { canonicalArtifactJsonV2 } from "../evidence/artifact-integrity.mjs";
 import { assertBoundedJsonStructure } from "../../lib/bounded-json.mjs";
 import { inspectCaseBrandProfileIds, unionCaseBrandProfileIds, } from "./case-brand-profile-references.mjs";
@@ -51,13 +51,13 @@ 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 public compatibility boundary. Only public schema 12 migrates 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 12 and 13 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) {
-            assertCurrentEvidenceHostnameShape(raw);
+            assertCurrentCaseShape(raw);
         }
     }
     const byDomain = new Map();
@@ -76,17 +76,23 @@ export function normalizeCaseStore(raw) {
     assignUniqueIds(cases);
     return { version: CASE_SCHEMA_VERSION, cases };
 }
-function assertCurrentEvidenceHostnameShape(raw) {
+function assertCurrentCaseShape(raw) {
     for (const item of boundedCaseList(raw).items) {
-        const evidenceHistory = objectRecord(item).evidenceHistory;
-        if (!Array.isArray(evidenceHistory))
-            continue;
-        for (const snapshot of evidenceHistory) {
+        const itemRecord = objectRecord(item);
+        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.`);
             }
         }
+        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.`);
+            }
+        }
     }
 }
 /**
@@ -388,7 +394,7 @@ function caseCollectionImportEnvelope(importedRaw) {
     }
     for (const reportValue of reports) {
         const report = objectRecord(reportValue);
-        assertOnlyEnvelopeKeys(report, rootVersion === CASE_SCHEMA_VERSION ? CLI_CASE_PACK_REPORT_KEYS : CLI_CASE_PACK_PUBLIC_REPORT_KEYS, 'CLI Case-pack report');
+        assertOnlyEnvelopeKeys(report, rootVersion === PUBLIC_CASE_SCHEMA_VERSION ? CLI_CASE_PACK_PUBLIC_REPORT_KEYS : CLI_CASE_PACK_REPORT_KEYS, 'CLI Case-pack report');
         if (report.schema !== CASE_REPORT_SCHEMA
             || !caseReportVersionMatchesCase(rootVersion, report.schemaVersion)
             || report.generatedAt !== root.exportedAt) {
@@ -420,7 +426,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 public compatibility boundary. Only public schema 12 migrates 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 12 and 13 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.`);
@@ -430,7 +436,7 @@ export function mergeCases(localCases, importedRaw) {
         throw new Error(`Expected a well-formed WHOISleuth Case export using schema ${CASE_SCHEMA_VERSION}; no data was changed.`);
     }
     if (importedVersion === CASE_SCHEMA_VERSION)
-        assertCurrentEvidenceHostnameShape(importedEnvelope);
+        assertCurrentCaseShape(importedEnvelope);
     const local = normalizeCaseStore(localCases).cases;
     const supportedImportedVersion = importedVersion ?? 0;
     const byDomain = new Map(local.map((item) => [item.domain, item]));

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

@@ -1,11 +1,101 @@
 // Pure, framework-neutral analyst-case records, evidence histories, bounded
 // record normalization, and analyst updates.
+import { canonicalRegistrableDomain } from "../../lib/registrable-domain.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 { 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 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,
+    });
+}
 // ---------------------------------------------------------------------------
 // Case normalization
 // ---------------------------------------------------------------------------
@@ -300,3 +390,148 @@ export function updateCase(cases, id, patch, nowIso) {
     next[index] = record;
     return { cases: next, record };
 }
+/**
+ * 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
+ * separate resolved contradiction assertion rather than being hidden inside a
+ * favourable disposition.
+ */
+export function recordCaseConclusion(cases, id, input, nowIso) {
+    const now = caseTimestampOrNull(nowIso) || new Date().toISOString();
+    const disposition = normalizeDisposition(input.disposition);
+    const reviewReasonCode = normalizeReviewReasonCode(input.reviewReasonCode);
+    if (disposition === 'unreviewed') {
+        throw new Error('Select a reviewed disposition before recording a conclusion.');
+    }
+    if (!reviewReasonCode) {
+        throw new Error('Select the reviewed reason before recording a conclusion.');
+    }
+    if (!Array.isArray(input.evidence) || !input.evidence.length) {
+        throw new Error('Select at least one observed fact for this conclusion.');
+    }
+    const invalidStance = input.evidence.find((item) => (!item || !['supports', 'contradicts', 'unresolved'].includes(item.stance)));
+    if (invalidStance)
+        throw new Error('A conclusion evidence relationship is invalid.');
+    if (!input.evidence.some((item) => item.stance === 'supports')) {
+        throw new Error('A conclusion requires at least one observed fact that supports it. Record only contradictory or unresolved material as an assertion instead.');
+    }
+    const current = cases.find((item) => item.id === id);
+    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 addedPins = withPins.record.evidencePins.filter((pin) => !existingPinIds.has(pin.id));
+    if (addedPins.length !== input.evidence.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 concluded = updateCase(withPins.cases, id, {
+        disposition,
+        reviewReasonCode,
+        decision: {
+            summary: input.summary,
+            rationale: input.rationale,
+            evidencePinIds: supportingPinIds,
+        },
+    }, now);
+    const contradictionRelations = addedPins.flatMap((pin, index) => (input.evidence[index]?.stance === 'contradicts'
+        ? [{ evidencePinId: pin.id, stance: 'contradicts' }]
+        : []));
+    if (contradictionRelations.length) {
+        const retainedSummary = concluded.record.decisions.at(-1)?.summary ?? 'Analyst conclusion';
+        concluded = updateCase(concluded.cases, id, {
+            assertion: {
+                kind: 'contradiction',
+                statement: `Counterevidence considered for: ${retainedSummary}`,
+                rationale: input.rationale,
+                evidenceRelations: contradictionRelations,
+                state: 'resolved',
+            },
+        }, now);
+    }
+    const unresolvedRelations = addedPins.flatMap((pin, index) => (input.evidence[index]?.stance === 'unresolved'
+        ? [{ evidencePinId: pin.id, stance: 'unresolved' }]
+        : []));
+    if (unresolvedRelations.length) {
+        const retainedSummary = concluded.record.decisions.at(-1)?.summary ?? 'Analyst conclusion';
+        concluded = updateCase(concluded.cases, id, {
+            assertion: {
+                kind: 'unknown',
+                statement: `Unresolved evidence considered for: ${retainedSummary}`,
+                rationale: input.rationale,
+                evidenceRelations: unresolvedRelations,
+                state: 'open',
+            },
+        }, now);
+    }
+    return concluded;
+}
+export function recordCaseInvestigationContext(cases, id, input, nowIso) {
+    const current = cases.find((item) => item.id === id);
+    if (!current)
+        throw new Error('That case no longer exists.');
+    const parsed = parseIncidentUrlContext(input.incidentUrl);
+    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);
+}
+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.');
+    const beforePinIds = new Set(current.evidencePins.map((pin) => pin.id));
+    const withPin = updateCase(cases, id, {
+        evidencePin: {
+            field: 'case.recheck_comparison',
+            category: 'recheck',
+            label: 'Recheck comparison',
+            value: input.comparisonSummary,
+            source: input.source,
+            sourceState: 'reviewed',
+            observedAt: input.observedAt,
+            collectionDepth: input.collectionDepth,
+            completeness: input.completeness,
+            truncated: false,
+            limitations: input.limitations,
+        },
+    }, now);
+    const comparisonPin = withPin.record.evidencePins.find((pin) => !beforePinIds.has(pin.id));
+    if (!comparisonPin)
+        throw new Error('The recheck comparison could not be retained.');
+    return updateCase(withPin.cases, id, {
+        observedEffectReview: {
+            state: input.state,
+            observedAt: input.observedAt,
+            sourceClass: 'analyst',
+            source: input.source,
+            completeness: input.completeness,
+            evidencePinId: comparisonPin.id,
+            followUpAt: input.followUpAt,
+            limitations: input.limitations,
+        },
+    }, now);
+}

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

@@ -2,7 +2,7 @@
 // deliberately separate from collected evidence snapshots: a pin describes a
 // fact selected by an analyst, a decision records analyst reasoning, and an
 // action records a reviewed external or internal follow-up.
-import { MAX_ASSERTION_PROVENANCE_LABELS, MAX_ASSERTION_PROVENANCE_MARKINGS, MAX_CASE_ACTION_BYTES, MAX_CASE_ACTION_EVENTS_PER_ACTION, MAX_CASE_ACTION_EVENTS_PER_CASE, MAX_CASE_ACTION_HISTORY_BYTES_PER_CASE, MAX_CASE_ACTIONS, MAX_CASE_ASSERTIONS, MAX_CASE_CHECKPOINT_FACTS, MAX_CASE_CLOSURES, MAX_CASE_DECISIONS, MAX_CASE_EVIDENCE_PINS, MAX_CASE_MANUAL_TRAIL_EVENTS, MAX_CASE_OBSERVED_EFFECT_REVIEWS, MAX_CASE_SIGHTINGS, MAX_DECISION_PIN_REFERENCES, MAX_RESPONSE_LABEL_LENGTH, MAX_RESPONSE_LIMITATION_LENGTH, MAX_RESPONSE_LIMITATIONS, MAX_RESPONSE_RATIONALE_LENGTH, MAX_RESPONSE_RECIPIENT_LENGTH, MAX_RESPONSE_REFERENCE_LENGTH, MAX_RESPONSE_VALUE_LENGTH, MAX_TRAIL_TARGET_LENGTH, } from "../contracts/case-portability.mjs";
+import { MAX_ASSERTION_PROVENANCE_LABELS, MAX_ASSERTION_PROVENANCE_MARKINGS, MAX_CASE_ACTION_BYTES, MAX_CASE_ACTION_EVENTS_PER_ACTION, MAX_CASE_ACTION_EVENTS_PER_CASE, MAX_CASE_ACTION_HISTORY_BYTES_PER_CASE, MAX_CASE_ACTIONS, MAX_CASE_ASSERTIONS, MAX_CASE_CHECKPOINT_FACTS, MAX_CASE_CLOSURES, MAX_CASE_DECISIONS, MAX_CASE_EVIDENCE_PINS, MAX_CASE_MANUAL_TRAIL_EVENTS, MAX_CASE_OBSERVED_EFFECT_REVIEWS, MAX_CASE_SIGHTINGS, MAX_DECISION_PIN_REFERENCES, MAX_RESPONSE_LABEL_LENGTH, MAX_RESPONSE_LIMITATION_LENGTH, MAX_RESPONSE_LIMITATIONS, MAX_RESPONSE_RATIONALE_LENGTH, MAX_RESPONSE_RECIPIENT_LENGTH, MAX_RESPONSE_REFERENCE_LENGTH, MAX_RESPONSE_VALUE_LENGTH, MAX_TRAIL_TARGET_LENGTH, CASE_SCHEMA_VERSION, } from "../contracts/case-portability.mjs";
 import { normalizeExplicitIsoTimestamp, normalizeLegacyIsoTimestamp } from "../evidence/observation.mjs";
 export { MAX_ASSERTION_PROVENANCE_LABELS, MAX_ASSERTION_PROVENANCE_MARKINGS, MAX_CASE_ACTION_BYTES, MAX_CASE_ACTION_EVENTS_PER_ACTION, MAX_CASE_ACTION_EVENTS_PER_CASE, MAX_CASE_ACTION_HISTORY_BYTES_PER_CASE, MAX_CASE_ACTIONS, MAX_CASE_ASSERTIONS, MAX_CASE_CHECKPOINT_FACTS, MAX_CASE_CLOSURES, MAX_CASE_DECISIONS, MAX_CASE_EVIDENCE_PINS, MAX_CASE_MANUAL_TRAIL_EVENTS, MAX_CASE_OBSERVED_EFFECT_REVIEWS, MAX_CASE_SIGHTINGS, MAX_DECISION_PIN_REFERENCES, MAX_RESPONSE_LABEL_LENGTH, MAX_RESPONSE_LIMITATION_LENGTH, MAX_RESPONSE_LIMITATIONS, MAX_RESPONSE_RATIONALE_LENGTH, MAX_RESPONSE_RECIPIENT_LENGTH, MAX_RESPONSE_REFERENCE_LENGTH, MAX_RESPONSE_VALUE_LENGTH, MAX_TRAIL_TARGET_LENGTH, };
 export const CASE_EVIDENCE_RELATION_STANCES = ['supports', 'contradicts', 'unresolved'];
@@ -118,8 +118,8 @@ const SIGHTING_CATEGORIES = new Set(CASE_SIGHTING_CATEGORIES);
 const SHA256_RE = /^[a-f0-9]{64}$/u;
 function currentActionNormalizationOptions(validEvidencePinIds) {
     return validEvidencePinIds
-        ? { sourceVersion: 13, validEvidencePinIds }
-        : { sourceVersion: 13 };
+        ? { sourceVersion: CASE_SCHEMA_VERSION, validEvidencePinIds }
+        : { sourceVersion: CASE_SCHEMA_VERSION };
 }
 function record(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
@@ -668,6 +668,9 @@ function normalizeAction(raw, fallback, options = {}) {
             : 'internal_review',
         recipient,
         contactSource: text(item.contactSource, MAX_RESPONSE_LABEL_LENGTH) || 'analyst_supplied',
+        routeObservedAt: options.sourceVersion != null && options.sourceVersion < 14
+            ? null
+            : optionalIso(item.routeObservedAt, options),
         contactLimitations: limitations(item.contactLimitations),
         dueAt: optionalIso(item.dueAt, options),
         state: history.state,
@@ -699,7 +702,7 @@ function mergeNormalizedActions(left, right, fallback) {
         history: [...left.history, ...right.history],
         historyOmitted: Math.max(left.historyOmitted, right.historyOmitted),
         historyLimitations: [...left.historyLimitations, ...right.historyLimitations],
-    }, fallback, { sourceVersion: 13 });
+    }, fallback, { sourceVersion: CASE_SCHEMA_VERSION });
 }
 function boundActionCollection(actions, fallback) {
     const keep = new Set();
@@ -719,7 +722,7 @@ function boundActionCollection(actions, fallback) {
     let bounded = actions.map((action) => {
         const history = action.history.filter((event) => keep.has(`${action.id}\u0000${event.id}`));
         const omitted = action.historyOmitted + action.history.length - history.length;
-        return normalizeAction({ ...action, history, historyOmitted: omitted }, fallback, { sourceVersion: 13 });
+        return normalizeAction({ ...action, history, historyOmitted: omitted }, fallback, { sourceVersion: CASE_SCHEMA_VERSION });
     });
     while (bytes(bounded) > MAX_CASE_ACTION_HISTORY_BYTES_PER_CASE) {
         const candidate = bounded
@@ -734,7 +737,7 @@ function boundActionCollection(actions, fallback) {
                 ...action,
                 history: action.history.filter((event) => event.id !== candidate.event.id),
                 historyOmitted: action.historyOmitted + 1,
-            }, fallback, { sourceVersion: 13 }));
+            }, fallback, { sourceVersion: CASE_SCHEMA_VERSION }));
     }
     if (bytes(bounded) > MAX_CASE_ACTION_HISTORY_BYTES_PER_CASE && bounded.length > 1) {
         const byteOmissionPattern = /^(\d+) earlier response actions? omitted by the per-Case response-history byte bound\.$/u;
@@ -859,10 +862,10 @@ export function appendCaseAction(current, raw, now) {
         historyOmitted: 0,
         createdAt: now,
         metadataUpdatedAt: now,
-    }, now, { sourceVersion: 13 });
+    }, now, { sourceVersion: CASE_SCHEMA_VERSION });
     if (!created)
         throw new Error('An action requires a recipient or internal owner.');
-    return normalizeCaseActions([...current, created], now, { sourceVersion: 13 });
+    return normalizeCaseActions([...current, created], now, { sourceVersion: CASE_SCHEMA_VERSION });
 }
 export function appendCaseActionTransition(current, actionId, raw, now, validPinIds) {
     const action = current.find((item) => item.id === actionId);
@@ -927,6 +930,7 @@ export function updateCaseAction(current, raw, now, validPinIds) {
         type: Object.hasOwn(patch, 'type') ? patch.type : existing.type,
         recipient: Object.hasOwn(patch, 'recipient') ? patch.recipient : existing.recipient,
         contactSource: Object.hasOwn(patch, 'contactSource') ? patch.contactSource : existing.contactSource,
+        routeObservedAt: Object.hasOwn(patch, 'routeObservedAt') ? patch.routeObservedAt : existing.routeObservedAt,
         contactLimitations: Object.hasOwn(patch, 'contactLimitations') ? patch.contactLimitations : existing.contactLimitations,
         dueAt: Object.hasOwn(patch, 'dueAt') ? patch.dueAt : existing.dueAt,
         followUpAt: Object.hasOwn(patch, 'followUpAt') ? patch.followUpAt : existing.followUpAt,
@@ -940,7 +944,7 @@ export function updateCaseAction(current, raw, now, validPinIds) {
     let updated = normalizeAction(metadata, now, currentActionNormalizationOptions(validPinIds));
     if (!updated)
         throw new Error('An action requires a recipient or internal owner.');
-    const materialChanged = ['type', 'recipient', 'contactSource', 'contactLimitations', 'originActionId']
+    const materialChanged = ['type', 'recipient', 'contactSource', 'routeObservedAt', 'contactLimitations', 'originActionId']
         .some((key) => Object.hasOwn(patch, key) && JSON.stringify(record(existing)[key]) !== JSON.stringify(record(updated)[key]));
     if (materialChanged && ['submitted', 'acknowledged', 'terminal'].includes(existing.state)) {
         throw new Error('Submitted or terminal action identity and recipient metadata cannot be rewritten; create a linked follow-on action instead.');