@slicedearth/whoisleuth-cli 2.5.1 → 2.7.0

package/packages/analysis/risk-scoring.mjs

@@ -6,20 +6,20 @@ const STATE_LABELS = Object.freeze({
     expiring: 'expiring/pending delete',
     registered: 'registered',
 });
-// Version 8 keeps unreviewed whole-page similarity as visible review context
-// without assigning it Risk points. Reviewed favicon and official-asset
-// observations remain bounded within the brand-presentation family, generic
-// operational properties remain supporting context, and missing evidence never
-// contributes points.
-export const RISK_MODEL_VERSION = 8;
+// Version 9 requires form-scoped password/destination evidence. Older page-wide
+// flags never establish that a password control belongs to an external form.
+export const RISK_MODEL_VERSION = 9;
 export const RISK_REVIEW_THRESHOLD = 70;
 const CURRENT_RISK_MODEL = Object.freeze({
     modelVersion: RISK_MODEL_VERSION,
     includePageBaselineMatch: false,
+    requireFormAttribution: true,
 });
+const RISK_MODEL_V8 = Object.freeze({ modelVersion: 8, includePageBaselineMatch: false, requireFormAttribution: false });
 const RISK_MODEL_V7 = Object.freeze({
     modelVersion: 7,
     includePageBaselineMatch: true,
+    requireFormAttribution: false,
 });
 const RISK_STATE_BASE = Object.freeze({
     registered: 6,
@@ -104,7 +104,7 @@ function scoreQuality(input) {
     if ([input.faviconMatch, input.faviconNearMatch, input.reusesOfficialAssets, input.pageBaselineMatch].some(hasBoolean)) {
         observedFamilies.push('brand-presentation');
     }
-    if ([input.hasPasswordField, input.hasExternalFormAction].some(hasBoolean) || typeof input.phishingLanguageMatch === 'string') {
+    if ([input.hasPasswordField, input.hasExternalFormAction, input.hasExternalPasswordForm].some(hasBoolean) || typeof input.phishingLanguageMatch === 'string') {
         observedFamilies.push('credential-lure');
     }
     if (calibrateExternalIntelligenceRisk(input.threatIntelligence, input.domain).eligibleProviderCount > 0) {
@@ -159,8 +159,8 @@ function explainRiskScoreInternal(input, excludedFamily, model) {
     if (typeof input.phishingLanguageMatch === 'string' && input.phishingLanguageMatch.trim()) {
         add('credential-lure', 'Suspicious urgency language observed', 8);
     }
-    if (input.hasPasswordField === true && input.hasExternalFormAction === true) {
-        add('credential-lure', 'Password form submits to an external origin', 10);
+    if (model.requireFormAttribution ? input.hasExternalPasswordForm === true : input.hasPasswordField === true && input.hasExternalFormAction === true) {
+        add('credential-lure', model.requireFormAttribution ? 'Password form declares an external destination' : 'Password form submits to an external origin', 10);
     }
     else if (input.hasPasswordField === true) {
         add('credential-lure', 'Login/password form present', 5);
@@ -254,6 +254,9 @@ export function computeRiskScore(input) {
 export function explainRiskScoreV7(input) {
     return explainRiskScoreInternal(input, null, RISK_MODEL_V7);
 }
+export function explainRiskScoreV8(input) {
+    return explainRiskScoreInternal(input, null, RISK_MODEL_V8);
+}
 // Retained only for deterministic offline comparison of reviewed calibration
 // datasets. Runtime lookups always use the current model above.
 export function explainRiskScoreV6(input) {

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

@@ -1,7 +1,7 @@
 import { MAX_SELECTED_FILES, SELECTED_FILE_MEDIA_TYPES } from "../contracts/selected-file-limits.mjs";
 import { array, enumeration, exactOptional, iso, text } from "../evidence/artifact-structure.mjs";
 import { readRetainedFileReference } from "../evidence/retained-file.mjs";
-import { readImageDerivation } from "../evidence/image-regions.mjs";
+import { declareImageDerivation, readImageDerivation } from "../evidence/image-regions.mjs";
 /** Case provenance is independent of deduplicated immutable content. */
 export function readCaseAttachment(value) {
     const item = exactOptional(value, ['id', 'fileName', 'mediaType', 'source', 'observedAt', 'retainedAt', 'digestSha256', 'byteLength'], ['derivation'], 'Case attachment');
@@ -50,6 +50,41 @@ export function mergeCaseAttachments(local, incoming) {
 export function caseAttachmentReferences(cases) {
     return cases.flatMap(record => (record.attachments ?? []).map(({ digestSha256, byteLength }) => ({ digestSha256, byteLength })));
 }
+/** Follow declared parents in one admitted Case's metadata; never resolve files or other Cases. */
+export function reviewCaseImageDerivation(attachment, retained) {
+    if (!attachment.derivation)
+        return null;
+    if (!Array.isArray(retained) || retained.length > MAX_SELECTED_FILES)
+        throw new TypeError('Image history exceeds the Case attachment bound.');
+    const references = new Map();
+    for (const item of retained)
+        references.set(item.id, references.has(item.id) ? null : item);
+    const steps = [];
+    const finish = (termination) => Object.freeze({ steps: Object.freeze(steps), termination });
+    const visited = new Set([attachment.id]);
+    let current = attachment;
+    for (let depth = 0; depth < MAX_SELECTED_FILES; depth++) {
+        const derivation = current.derivation;
+        const declaration = declareImageDerivation(derivation);
+        const parent = references.get(derivation.sourceAttachmentId);
+        const matches = parent?.mediaType === 'image/png'
+            && parent.digestSha256 === declaration.source.digestSha256
+            && parent.byteLength === declaration.source.byteLength;
+        const parentReference = parent === undefined ? 'missing' : matches ? 'matching' : 'conflicting';
+        steps.push(Object.freeze({ declaration, parentReference, parentHasDeclaredEdits: matches ? Boolean(parent?.derivation) : null }));
+        if (parentReference === 'missing')
+            return finish('missing_parent');
+        if (!matches || !parent)
+            return finish('conflicting_parent');
+        if (visited.has(parent.id))
+            return finish('cycle');
+        if (!parent.derivation)
+            return finish('no_further_declaration');
+        visited.add(parent.id);
+        current = parent;
+    }
+    return finish('limit');
+}
 export function addCaseAttachments(record, attachments, updatedAt) {
     iso(updatedAt, 'Case update time');
     return { ...record, attachments: mergeCaseAttachments(record.attachments, attachments) ?? [], updatedAt };

package/packages/cases/case-checkpoint-receipts.mjs

@@ -0,0 +1,68 @@
+import { MAX_CASE_EVIDENCE_PINS, COLLECTION_RECEIPT_CASE_SCHEMA_VERSION } from "../contracts/case-portability.mjs";
+import { parseLookupCollectionReceipt, lookupCollectionReceiptIdentity } from "../evidence/lookup-collection-receipt.mjs";
+import { canonicalArtifactJsonV2 } from "../evidence/artifact-integrity.mjs";
+/** Removing the last pin in a group also removes its context. No other pin edit
+ * needs bookkeeping, and normalisation never changes a pin or checkpoint ID. */
+export function readCaseCheckpointReceipts(value, pins, sourceVersion) {
+    if (value === undefined)
+        return undefined;
+    if (sourceVersion != null && sourceVersion < COLLECTION_RECEIPT_CASE_SCHEMA_VERSION) {
+        throw new TypeError('Checkpoint collection receipts require Case schema 20.');
+    }
+    if (!Array.isArray(value) || value.length > MAX_CASE_EVIDENCE_PINS) {
+        throw new TypeError('Checkpoint collection receipts must fit the retained evidence-pin limit.');
+    }
+    const groups = new Set(pins.map(pin => pin.checkpointId).filter(Boolean));
+    const entries = new Map();
+    for (const raw of value) {
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw)
+            || Object.keys(raw).length !== 2 || !Object.hasOwn(raw, 'checkpointId') || !Object.hasOwn(raw, 'collectionReceipt')
+            || typeof raw.checkpointId !== 'string' || !/^[A-Za-z0-9_-]{1,64}$/u.test(raw.checkpointId)) {
+            throw new TypeError('A checkpoint collection receipt is malformed.');
+        }
+        const collectionReceipt = parseLookupCollectionReceipt(raw.collectionReceipt);
+        if (!collectionReceipt || collectionReceipt.targetClass !== 'domain')
+            throw new TypeError('A Case checkpoint requires a domain collection receipt.');
+        const previous = entries.get(raw.checkpointId);
+        if (previous && lookupCollectionReceiptIdentity(previous.collectionReceipt) !== lookupCollectionReceiptIdentity(collectionReceipt)) {
+            throw new TypeError('Conflicting collection receipts use the same checkpoint identity. No evidence was changed.');
+        }
+        entries.set(raw.checkpointId, { checkpointId: raw.checkpointId, collectionReceipt });
+    }
+    const retained = [...entries.values()].filter(entry => groups.has(entry.checkpointId))
+        .sort((a, b) => a.checkpointId < b.checkpointId ? -1 : a.checkpointId > b.checkpointId ? 1 : 0);
+    for (const entry of retained) {
+        if (pins.some(pin => pin.checkpointId === entry.checkpointId && pin.collectionDepth !== entry.collectionReceipt.requestedDepth)) {
+            throw new TypeError('The checkpoint collection receipt does not match its retained pins.');
+        }
+    }
+    return retained.length ? retained : undefined;
+}
+export function mergeCaseCheckpointReceipts(left, right, pins) {
+    const before = readCaseCheckpointReceipts(left.checkpointCollectionReceipts, left.evidencePins) ?? [];
+    const incoming = readCaseCheckpointReceipts(right.checkpointCollectionReceipts, right.evidencePins) ?? [];
+    // Each input is bounded independently. Deduplicate before applying the final
+    // group bound so re-importing a full Case remains idempotent.
+    const byId = new Map(before.map(entry => [entry.checkpointId, entry]));
+    for (const entry of incoming) {
+        const previous = byId.get(entry.checkpointId);
+        if (previous && lookupCollectionReceiptIdentity(previous.collectionReceipt) !== lookupCollectionReceiptIdentity(entry.collectionReceipt)) {
+            throw new TypeError('Conflicting collection receipts use the same checkpoint identity. No evidence was changed.');
+        }
+        byId.set(entry.checkpointId, entry);
+    }
+    const groups = new Set(pins.map(pin => pin.checkpointId));
+    const retained = [...byId.values()].filter(entry => groups.has(entry.checkpointId));
+    for (const entry of retained) {
+        // A colliding group ID must not lend its receipt to unrelated retained
+        // pins. Identical imports and partial retention remain valid.
+        const sourcePins = [before.some(item => item.checkpointId === entry.checkpointId) ? left.evidencePins : [],
+            incoming.some(item => item.checkpointId === entry.checkpointId) ? right.evidencePins : []].flat();
+        for (const pin of pins.filter(pin => pin.checkpointId === entry.checkpointId)) {
+            if (!sourcePins.some(source => source.id === pin.id && canonicalArtifactJsonV2(source) === canonicalArtifactJsonV2(pin))) {
+                throw new TypeError('A checkpoint identity belongs to different retained pins. Its collection context cannot be reassigned.');
+            }
+        }
+    }
+    return readCaseCheckpointReceipts(retained, pins);
+}

package/packages/cases/case-containment-handoff.mjs

@@ -0,0 +1,195 @@
+import { projectCaseForAudience } from "./case-record-projection.mjs";
+import { readEditableCaseExport } from "./case-export-input.mjs";
+import { array, enumeration, exact, iso, text } from "../evidence/artifact-structure.mjs";
+import { escapeCaseMarkdownInline } from "./case-markdown.mjs";
+import { MAX_CASE_ASSERTIONS, MAX_CASE_EVIDENCE_PINS } from "../contracts/case-portability.mjs";
+import { caseSelectedEvidenceSourceLimitations } from "./case-evidence-links.mjs";
+export const CASE_CONTAINMENT_INPUT_SCHEMA = 'whoisleuth.internal-containment.input';
+export const CASE_CONTAINMENT_HANDOFF_SCHEMA = 'whoisleuth.internal-containment';
+export const CASE_CONTAINMENT_VERSION = 1;
+export const MAX_CONTAINMENT_ASSERTIONS = 20;
+export const MAX_CONTAINMENT_PINS = 40;
+export const MAX_CONTAINMENT_OUTPUT_BYTES = 128 * 1024;
+export const CONTAINMENT_RECIPIENT_ROLES = [
+    'security_operations',
+    'identity_response',
+    'endpoint_response',
+    'network_response',
+];
+const ROLE_GUIDANCE = {
+    security_operations: [
+        'Confirm the responsible internal owner and track the selected requests independently of external removal.',
+        'Separate reported actions, retained observations and unresolved evidence before authorising a control.',
+    ],
+    identity_response: [
+        'Review the selected requests against authorised account, session and application-grant evidence in the identity system.',
+        'Do not treat a reported password entry, sign-in approval or provider resolution as proof of account compromise or recovery.',
+    ],
+    endpoint_response: [
+        'Review the selected requests against authorised device evidence before deciding whether isolation, collection or remediation is needed.',
+        'Do not execute supplied commands or attachments; a reported execution is not a verified device outcome.',
+    ],
+    network_response: [
+        'Review exact scope, collateral effects and an appropriate review/expiry period before applying an approved network control.',
+        'Shared infrastructure and literal indicators do not establish ownership, maliciousness or an appropriate blocking scope.',
+    ],
+};
+function uniqueIds(value, maximum, label) {
+    const ids = array(value, label, maximum).map((id) => text(id, label, 240));
+    if (new Set(ids).size !== ids.length)
+        throw new TypeError(`${label} must be unique.`);
+    return ids;
+}
+export function readContainmentSelection(raw) {
+    const value = exact(raw, ['audience', 'recipientRole', 'assertionIds', 'evidencePinIds'], 'Containment handoff selection');
+    return {
+        audience: enumeration(value.audience, ['internal', 'trusted', 'public'], 'Handoff audience'),
+        recipientRole: enumeration(value.recipientRole, CONTAINMENT_RECIPIENT_ROLES, 'Internal recipient role'),
+        assertionIds: uniqueIds(value.assertionIds, MAX_CONTAINMENT_ASSERTIONS, 'Selected follow-ups'),
+        evidencePinIds: uniqueIds(value.evidencePinIds, MAX_CONTAINMENT_PINS, 'Selected supporting pins'),
+    };
+}
+/** Select retained assertions; never infer completed containment from Case or provider status. */
+export function previewCaseContainmentHandoff(record, raw, generatedAt) {
+    iso(generatedAt, 'Handoff generation time');
+    const selection = readContainmentSelection(raw);
+    array(record.assertions, 'Retained Case assertions', MAX_CASE_ASSERTIONS);
+    array(record.evidencePins, 'Retained Case pins', MAX_CASE_EVIDENCE_PINS);
+    const followUps = record.assertions.filter((item) => item.kind === 'next_step');
+    const original = selection.assertionIds.map((id) => {
+        const matches = followUps.filter((item) => item.id === id);
+        if (matches.length !== 1)
+            throw new TypeError('A selected follow-up is missing or ambiguous; refresh the selection.');
+        return matches[0];
+    });
+    const linkedIds = new Set(original.flatMap((item) => item.evidencePinIds));
+    for (const id of selection.evidencePinIds) {
+        if (!linkedIds.has(id) || record.evidencePins.filter((pin) => pin.id === id).length !== 1)
+            throw new TypeError('Select only uniquely retained pins linked to the selected follow-ups.');
+    }
+    const permitted = selection.audience !== 'public';
+    // Reuse the canonical audience policy before constructing a narrow projection.
+    const projected = projectCaseForAudience(record, selection.audience);
+    const pins = permitted
+        ? projected.evidencePins.filter((pin) => selection.evidencePinIds.includes(pin.id))
+        : [];
+    const assertions = permitted
+        ? original.map((item) => {
+            const selected = projected.assertions.find((assertion) => assertion.id === item.id);
+            return {
+                id: selected.id,
+                kind: 'next_step',
+                statement: selected.statement,
+                rationale: selected.rationale,
+                state: selected.state,
+                createdAt: selected.createdAt,
+                updatedAt: selected.updatedAt,
+                provenance: selected.provenance ?? null,
+                recheck: selected.recheck ?? null,
+                evidence: selected.evidencePinIds.map((id) => ({
+                    evidencePinId: id,
+                    stance: selected.evidenceRelations?.find((relation) => relation.evidencePinId === id)
+                        ?.stance ?? 'not_recorded',
+                    state: pins.some((pin) => pin.id === id)
+                        ? 'included'
+                        : record.evidencePins.some((pin) => pin.id === id)
+                            ? 'not_selected'
+                            : 'unavailable',
+                })),
+            };
+        })
+        : [];
+    const missingContext = assertions.some((item) => !item.evidence.length || item.evidence.some((link) => link.state !== 'included'));
+    const report = {
+        schema: CASE_CONTAINMENT_HANDOFF_SCHEMA,
+        version: CASE_CONTAINMENT_VERSION,
+        generatedAt,
+        audience: selection.audience,
+        recipientRole: selection.recipientRole,
+        case: { id: projected.id, domain: projected.domain, status: projected.status },
+        state: !permitted ||
+            !assertions.length ||
+            missingContext ||
+            pins.some((pin) => pin.completeness !== 'complete' || pin.truncated === true)
+            ? 'partial'
+            : 'reviewed',
+        reviewRequired: true,
+        actionsPerformed: false,
+        assertions,
+        evidencePins: pins,
+        disclosure: {
+            exportAllowed: permitted && assertions.length > 0,
+            included: permitted
+                ? [
+                    'Case identifier, domain and recorded status',
+                    'Only selected next-step statements, rationale, states and recording times',
+                    'Exact selected supporting pins and separately qualified evidence relationships',
+                ]
+                : ['Case identifier, domain and recorded status only'],
+            excluded: [
+                'Unselected assertions and evidence',
+                'Case title, notes, contacts, action recipients and original files',
+                'Raw upstream responses, automatic assignments and control execution',
+                ...(permitted ? [] : ['Internal follow-up statements and their supporting pins']),
+            ],
+            caution: 'Selected statements and pin values can contain sensitive analyst text or exact scope. Review each included value for the intended recipient; minimisation is not automatic anonymisation.',
+        },
+        nextSteps: [...ROLE_GUIDANCE[selection.recipientRole]],
+        limitations: [
+            'These are retained analyst requests, not verified assignments, executed controls or independent recovery results.',
+            'Open and resolved assertion states are preserved as recorded. External provider resolution, object closure and Case status do not resolve open internal requests.',
+            'Unselected or missing supporting pins remain explicit. A linked pin may support, contradict or leave a request unresolved; linkage does not establish truth.',
+            'This local handoff sends no message, changes no Case state and includes no original attachment bytes.',
+            ...caseSelectedEvidenceSourceLimitations(pins, record.evidenceLinks, pins.map(pin => pin.id)),
+        ],
+    };
+    if (new TextEncoder().encode(JSON.stringify(report)).byteLength > MAX_CONTAINMENT_OUTPUT_BYTES)
+        throw new TypeError('The selected handoff exceeds 128 KiB. Choose fewer follow-ups or pins; nothing was silently omitted.');
+    return report;
+}
+export function buildCaseContainmentHandoff(record, selection, generatedAt, disclosureReviewed) {
+    const report = previewCaseContainmentHandoff(record, selection, generatedAt);
+    if (!disclosureReviewed || !report.disclosure.exportAllowed)
+        throw new TypeError('Review the audience disclosure and select at least one retained follow-up for an internal or trusted handoff.');
+    return report;
+}
+export function readCaseContainmentInput(raw, generatedAt) {
+    const input = exact(raw, ['schema', 'version', 'caseExport', 'caseId', 'selection', 'disclosureReviewed'], 'Containment handoff input');
+    if (input.schema !== CASE_CONTAINMENT_INPUT_SCHEMA || input.version !== CASE_CONTAINMENT_VERSION)
+        throw new TypeError('Unsupported containment handoff input version.');
+    const caseId = text(input.caseId, 'Selected Case ID', 240);
+    const selected = readEditableCaseExport(JSON.stringify(input.caseExport)).filter((record) => record.id === caseId);
+    if (selected.length !== 1)
+        throw new TypeError('Select one unambiguous Case from the supported export.');
+    if (input.disclosureReviewed !== true)
+        throw new TypeError('The selected handoff requires an explicit audience-disclosure review.');
+    return buildCaseContainmentHandoff(selected[0], readContainmentSelection(input.selection), generatedAt, true);
+}
+export function formatCaseContainmentHandoff(report) {
+    const escape = escapeCaseMarkdownInline;
+    const lines = [
+        `# Internal containment handoff`,
+        '',
+        `Audience: ${report.audience} · ${report.recipientRole.replaceAll('_', ' ')}`,
+        `Case: ${escape(report.case.domain)} · ${escape(report.case.id)} · recorded status ${escape(report.case.status)}`,
+        `Generated: ${report.generatedAt} · coverage ${report.state} · no actions performed`,
+        '',
+        '## Selected retained requests',
+        '',
+    ];
+    for (const item of report.assertions) {
+        lines.push(`- ${escape(item.statement)} — ${item.state} (${escape(item.id)})`);
+        if (item.rationale)
+            lines.push(`  Rationale: ${escape(item.rationale)}`);
+        lines.push(`  Recorded ${escape(item.createdAt)}; updated ${escape(item.updatedAt)}.`);
+        for (const link of item.evidence)
+            lines.push(`  Evidence ${escape(link.evidencePinId)}: ${link.stance}; ${link.state.replaceAll('_', ' ')}.`);
+        if (!item.evidence.length)
+            lines.push('  No supporting context was linked.');
+    }
+    lines.push('', '## Selected supporting evidence', '');
+    for (const pin of report.evidencePins)
+        lines.push(`- ${escape(pin.label)} (${escape(pin.id)}): ${escape(pin.value)}`, `  Source: ${escape(pin.source)}; observed ${escape(pin.observedAt ?? 'unknown')}; ${pin.completeness}${pin.truncated ? '; truncated' : ''}.`, ...pin.limitations.map((value) => `  Limitation: ${escape(value)}`));
+    lines.push('', '## Recipient review', '', ...report.nextSteps.map((value) => `- ${value}`), '', '## Boundaries', '', ...report.limitations.map((value) => `- ${value}`));
+    return `${lines.join('\n')}\n`;
+}

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

@@ -115,6 +115,34 @@ export function caseEvidenceLinkIssues(links, pins) {
         cyclic: !link.withdrawal && link.kind === 'derived_from' && reaches(graph, link.toPinId, link.fromPinId),
     }));
 }
+/** Follow declared sources, not automatic context matches or withdrawn links. */
+export function traceCaseEvidenceSources(links, rootPinIds) {
+    array(links, 'Retained evidence relationships', MAX_CASE_EVIDENCE_LINKS);
+    const roots = [...new Set(array(rootPinIds, 'Selected evidence pins', MAX_CASE_EVIDENCE_PINS).map(identifier))];
+    const neighbours = new Map();
+    function add(from, to, linkId) {
+        const entries = neighbours.get(from) ?? [];
+        entries.push({ linkId, pinId: to });
+        neighbours.set(from, entries);
+    }
+    for (const link of links)
+        if (!link.withdrawal) {
+            add(link.fromPinId, link.toPinId, link.id);
+            if (link.kind === 'shared_source')
+                add(link.toPinId, link.fromPinId, link.id);
+        }
+    const pinIds = new Set(roots), linkIds = new Set();
+    // Set iteration visits newly reached pins once, including unresolved references.
+    for (const pinId of pinIds)
+        for (const edge of neighbours.get(pinId) ?? []) {
+            linkIds.add(edge.linkId);
+            pinIds.add(edge.pinId);
+        }
+    return {
+        rootPinIds: roots, pinIds: [...pinIds], linkIds: [...linkIds],
+        withdrawnLinkIds: links.filter(link => link.withdrawal && (pinIds.has(link.fromPinId) || pinIds.has(link.toPinId))).map(link => link.id),
+    };
+}
 /** Matching context is disclosed, never counted as independent corroboration. */
 export function caseEvidenceSharedContext(pins) {
     const groups = new Map();
@@ -133,3 +161,19 @@ export function caseEvidenceSharedContext(pins) {
     }
     return [...groups.values()].filter(group => group.pinIds.length > 1);
 }
+export const CASE_SELECTED_EVIDENCE_SOURCE_LIMITATION = 'Selected evidence has retained shared-source or derivation context. Multiple references do not establish independent observations; underlying reporting or collection methods may remain unknown. Relationship details are not included in this output.';
+/** Qualify a narrow disclosure without exposing relationship identities or private basis text. */
+export function caseSelectedEvidenceSourceLimitations(pins, links, selectedPinIds) {
+    array(pins, 'Retained evidence pins', MAX_CASE_EVIDENCE_PINS);
+    array(links ?? [], 'Retained evidence relationships', MAX_CASE_EVIDENCE_LINKS);
+    array(selectedPinIds, 'Selected evidence pins', MAX_CASE_EVIDENCE_PINS);
+    const requested = new Set(selectedPinIds);
+    const selectedPins = pins.filter(pin => requested.has(pin.id));
+    const selected = new Set(selectedPins.map(pin => pin.id));
+    if (!selected.size)
+        return [];
+    const declared = links?.some(link => !link.withdrawal
+        && (selected.has(link.fromPinId) || selected.has(link.toPinId)));
+    return declared || caseEvidenceSharedContext(selectedPins).length
+        ? [CASE_SELECTED_EVIDENCE_SOURCE_LIMITATION] : [];
+}

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

@@ -5,7 +5,8 @@ import { normalizeOpportunityModelVersion } from "../analysis/opportunity-scorin
 import { normalizeRiskModelVersion } from "../analysis/risk-scoring.mjs";
 import { latestObservationCohort } from "../evidence/latest-observations.mjs";
 import { normalizeExplicitIsoTimestamp } from "../evidence/observation.mjs";
-import { EVIDENCE_FOLLOW_UP_CASE_SCHEMA_VERSION, PUBLISHED_V2_3_CASE_SCHEMA_VERSION } from "../contracts/case-portability.mjs";
+import { COLLECTION_RECEIPT_CASE_SCHEMA_VERSION, EVIDENCE_FOLLOW_UP_CASE_SCHEMA_VERSION, OBJECT_RESPONSE_CASE_SCHEMA_VERSION, PUBLISHED_V2_3_CASE_SCHEMA_VERSION } from "../contracts/case-portability.mjs";
+import { parseLookupCollectionReceipt, lookupCollectionReceiptIdentity } from "../evidence/lookup-collection-receipt.mjs";
 import { validWebObservationMode } from "../evidence/lookup-target.mjs";
 import { normalizeWebCollectionQuality, webCollectionAllowsComparison } from "../evidence/collection-quality.mjs";
 import { 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, } from "./case-record-contracts.mjs";
@@ -113,6 +114,7 @@ const DEEP_SIGNAL_FIELDS = [
     'httpCrossOriginRedirect', 'httpHttpsDowngrade', 'httpContentType', 'httpSecurityHeaders',
     'faviconMatch', 'faviconNearMatch', 'reusesOfficialAssets', 'hasPasswordField', 'hasExternalFormAction', 'phishingLanguageMatch',
     'pageBaselineMatch',
+    'hasExternalPasswordForm',
 ];
 // Ordered list of the fields that make up a snapshot's *material* identity -
 // everything except capture timestamps, snapshot id and source. `scanDepth` is
@@ -124,6 +126,7 @@ const MATERIAL_FIELD_ORDER = [
     'webObservationMode',
     'scanDepth',
     'webCollectionQuality',
+    'collectionReceipt',
     'availability', 'confidence', 'riskModelVersion', 'riskScore', 'opportunityModelVersion', 'opportunityScore',
     'riskFactors', 'opportunityFactors',
     'registrar', 'createdDate', 'expiryDate', 'nameservers',
@@ -135,6 +138,7 @@ const MATERIAL_FIELD_ORDER = [
     'privacyProtected', 'idnReferenceMatch', 'pageBaselineMatch', 'hasActiveBrandProfile',
     'profileContextState', 'profileContextLimitation',
     'mutationTypes',
+    'hasExternalPasswordForm',
 ];
 // The canonical, comparison-safe value of a material field. Registrar casing,
 // nameserver order, and sub-day timestamps are collapsed so they can never
@@ -176,7 +180,7 @@ function isEmptyMaterial(value) {
 }
 // Fields that describe the capture rather than assert evidence, so they never
 // on their own keep an otherwise-empty snapshot alive.
-const NON_EVIDENCE_MATERIAL = new Set(['inputHostname', 'observationHostname', 'webObservationMode', 'scanDepth', 'webCollectionQuality', 'confidence']);
+const NON_EVIDENCE_MATERIAL = new Set(['inputHostname', 'observationHostname', 'webObservationMode', 'scanDepth', 'webCollectionQuality', 'collectionReceipt', 'confidence']);
 // A snapshot with no material evidence (only timestamps/source/depth, or only a
 // bare confidence/unknown-availability) is dropped rather than added to a
 // timeline.
@@ -196,7 +200,7 @@ function canonicalMaterialString(snapshot, legacyOrder = false) {
         const value = materialValue(field, snapshot, legacyOrder);
         // Optional collection context does not alter historical fingerprints when
         // absent; recorded context separates otherwise-identical captures.
-        if ((field === 'inputHostname' || field === 'observationHostname' || field === 'webObservationMode' || field === 'webCollectionQuality') && value === null)
+        if ((field === 'inputHostname' || field === 'observationHostname' || field === 'webObservationMode' || field === 'webCollectionQuality' || field === 'collectionReceipt' || field === 'hasExternalPasswordForm') && value === null)
             continue;
         canonical[field] = value;
     }
@@ -218,11 +222,30 @@ export function normalizeSnapshot(raw, options = {}) {
     const built = buildSnapshot(raw, options);
     return built ? built.snapshot : null;
 }
+/** Shared artefacts use receipt-free identities, not hashes of private choices.
+ * Unchanged historical histories keep their exact identifiers. */
+export function caseEvidenceWithoutCollectionReceipts(record) {
+    if (!Array.isArray(record.evidenceHistory))
+        return [];
+    if (!record.evidenceHistory.some(snapshot => snapshot?.collectionReceipt !== undefined)) {
+        return structuredClone(record.evidenceHistory);
+    }
+    return normalizeEvidenceHistory(record.evidenceHistory.map(snapshot => {
+        if (!snapshot || typeof snapshot !== 'object')
+            return snapshot;
+        const { collectionReceipt: _receipt, ...evidence } = snapshot;
+        return evidence;
+    }), {
+        fallback: null, caseDomain: record.domain,
+    });
+}
 /** @returns {{ snapshot: CaseEvidenceSnapshot, material: string } | null} */
 function buildSnapshot(raw, options) {
     if (!raw || typeof raw !== 'object')
         return null;
     const record = objectRecord(raw);
+    if (record.hasExternalPasswordForm !== undefined && options.sourceVersion != null && options.sourceVersion < OBJECT_RESPONSE_CASE_SCHEMA_VERSION)
+        throw new TypeError('Password-form attribution requires Case schema 18 or later; historical evidence was not reinterpreted.');
     if (record.factorOrder !== undefined && record.factorOrder !== 'code-unit-v1')
         return null;
     const historicalSchema = options.sourceVersion !== undefined && Number(options.sourceVersion) <= PUBLISHED_V2_3_CASE_SCHEMA_VERSION;
@@ -232,6 +255,13 @@ function buildSnapshot(raw, options) {
     // captures declare code-unit ordering; the declaration survives every save.
     const legacyOrder = historicalSchema || (record.factorOrder === undefined && typeof record.fingerprint === 'string');
     const scanDepth = normalizeScanDepth(record.scanDepth);
+    const collectionReceipt = parseLookupCollectionReceipt(record.collectionReceipt);
+    if (collectionReceipt && options.sourceVersion != null && options.sourceVersion < COLLECTION_RECEIPT_CASE_SCHEMA_VERSION) {
+        throw new TypeError('Collection receipts require Case schema 20 or later; historical evidence was not reinterpreted.');
+    }
+    if (collectionReceipt && (collectionReceipt.targetClass !== 'domain' || collectionReceipt.requestedDepth !== scanDepth)) {
+        throw new TypeError('Collection receipt does not match the Case assessment.');
+    }
     const httpSummary = normalizeHttpSummary(record);
     const webCollectionQuality = normalizeWebCollectionQuality(record.webCollectionQuality, scanDepth);
     if (webCollectionQuality && options.sourceVersion != null && options.sourceVersion < EVIDENCE_FOLLOW_UP_CASE_SCHEMA_VERSION) {
@@ -255,6 +285,7 @@ function buildSnapshot(raw, options) {
         ...(acceptsObservationHostname && scanDepth !== 'fast' && record.webObservationMode === 'selected_url' ? { webObservationMode: record.webObservationMode } : {}),
         scanDepth,
         ...(webCollectionQuality ? { webCollectionQuality } : {}),
+        ...(collectionReceipt ? { collectionReceipt } : {}),
         availability: evidenceString(record.availability),
         confidence: evidenceString(record.confidence),
         riskModelVersion: normalizeRiskModelVersion(record.riskModelVersion),
@@ -288,6 +319,7 @@ function buildSnapshot(raw, options) {
         reusesOfficialAssets: boolOrNull(record.reusesOfficialAssets),
         hasPasswordField: boolOrNull(record.hasPasswordField),
         hasExternalFormAction: boolOrNull(record.hasExternalFormAction),
+        ...(record.hasExternalPasswordForm === undefined ? {} : { hasExternalPasswordForm: boolOrNull(record.hasExternalPasswordForm) }),
         phishingLanguageMatch: evidenceString(record.phishingLanguageMatch),
         privacyProtected: boolOrNull(record.privacyProtected),
         idnReferenceMatch: boolOrNull(record.idnReferenceMatch),
@@ -308,7 +340,7 @@ function buildSnapshot(raw, options) {
     if (fields.opportunityScore === null && fields.opportunityFactors.length === 0)
         fields.opportunityModelVersion = null;
     if (webCollectionQuality) {
-        for (const field of ['hasPasswordField', 'hasExternalFormAction', 'pageBaselineMatch', 'faviconMatch', 'faviconNearMatch', 'reusesOfficialAssets']) {
+        for (const field of ['hasPasswordField', 'hasExternalFormAction', 'hasExternalPasswordForm', 'pageBaselineMatch', 'faviconMatch', 'faviconNearMatch', 'reusesOfficialAssets']) {
             if (fields[field] === false && !webCollectionAllowsComparison(field, webCollectionQuality, scanDepth))
                 fields[field] = null;
         }
@@ -338,6 +370,7 @@ function buildSnapshot(raw, options) {
             reusesOfficialAssets: null,
             hasPasswordField: null,
             hasExternalFormAction: null,
+            ...(record.hasExternalPasswordForm === undefined ? {} : { hasExternalPasswordForm: null }),
             phishingLanguageMatch: null,
             pageBaselineMatch: null,
         });
@@ -519,9 +552,14 @@ function buildEvidenceTimeline(history, enforceCollectionQuality) {
         const incomparableReasons = orderingLimitation
             ? ['other']
             : comparable ? incomparableReasonsForEvidence(previous.snapshot, snapshot, enforceCollectionQuality) : [];
-        if (comparable && !changes.length && !incomparableReasons.length
-            && canonicalMaterialString(previous.snapshot) !== canonicalMaterialString(snapshot))
-            incomparableReasons.push('other');
+        const collectionContextChanged = Boolean(comparable
+            && lookupCollectionReceiptIdentity(previous.snapshot.collectionReceipt) !== lookupCollectionReceiptIdentity(snapshot.collectionReceipt));
+        if (comparable && !changes.length && !incomparableReasons.length) {
+            const { collectionReceipt: _beforeReceipt, ...before } = previous.snapshot;
+            const { collectionReceipt: _afterReceipt, ...after } = snapshot;
+            if (canonicalMaterialString(before) !== canonicalMaterialString(after))
+                incomparableReasons.push('other');
+        }
         return {
             snapshot,
             isBaseline,
@@ -530,6 +568,7 @@ function buildEvidenceTimeline(history, enforceCollectionQuality) {
             hasIncomparableChange: incomparableReasons.length > 0,
             incomparableReasons,
             orderingLimitation,
+            collectionContextChanged,
         };
     });
 }
@@ -583,6 +622,7 @@ const COMPARE_FIELDS = [
     { field: 'reusesOfficialAssets', scope: 'web', label: 'Official asset reuse', type: 'signal', depthGate: 'both-deep' },
     { field: 'hasPasswordField', scope: 'web', label: 'Password form', type: 'signal', depthGate: 'both-deep' },
     { field: 'hasExternalFormAction', scope: 'web', label: 'External form action', type: 'signal', depthGate: 'both-deep' },
+    { field: 'hasExternalPasswordForm', scope: 'web', label: 'Password form with declared external destination', type: 'signal', depthGate: 'both-deep' },
     { field: 'phishingLanguageMatch', scope: 'web', label: 'Phishing language', type: 'phishing', depthGate: 'both-deep' },
     { field: 'mutationTypes', scope: 'hostname', label: 'Mutation types', type: 'set' },
 ];
@@ -809,6 +849,10 @@ function compareField(spec, before, after) {
             return null;
     }
 }
+/** Field scope is owned by the same specification that gates comparisons. */
+export function caseEvidenceFieldScope(field) {
+    return COMPARE_FIELDS.find(spec => spec.field === field)?.scope ?? null;
+}
 /**
  * Diffs two normalized snapshots into a bounded, stably-ordered list of
  * material changes. Timestamps, source, id and fingerprint are ignored;