@slicedearth/whoisleuth-cli 2.5.1 → 2.6.0

package/cli/intake-command.mjs

@@ -2,6 +2,8 @@ import { readBoundedRegularFile } from "../lib/bounded-file.mjs";
 import { MAX_MESSAGE_INTAKE_BYTES, MESSAGE_INTAKE_INPUTS } from "../packages/contracts/message-intake.mjs";
 import { reviewSelectedInputInWorker } from "./selected-input-worker.mjs";
 import { reviewIdentityIncident } from "../packages/investigation/identity-incident-review.mjs";
+import { intakeIndicators, intakeIndicatorSource } from "../packages/investigation/intake-indicators.mjs";
+import { MAX_INTAKE_CONTEXT_BYTES, applyIntakeContextInput } from "../packages/investigation/intake-context.mjs";
 import { selectReceiverTrust, authenticationHeaderLabel } from "../packages/investigation/mail-authentication-review.mjs";
 import { CliUsageError } from "./errors.mjs";
 import { formatJsonDocument } from "./formatters/json.mjs";
@@ -33,6 +35,28 @@ export function formatMessageIntake(report) {
                 lines.push(`  Ambiguous parameters: ${link.authorisation.duplicateParameters.join(', ')}`);
         }
     }
+    for (const indicator of intakeIndicators(report))
+        lines.push(`${indicator.id}: ${indicator.kind.toUpperCase()} ${indicator.value} · literal selected text · ${indicator.location.partId}${indicator.location.page ? ` page ${indicator.location.page}` : ''} · source ${intakeIndicatorSource(report, indicator)}`);
+    if (report.schemaVersion === 2) {
+        lines.push(`Indicator coverage: ${report.indicatorCoverage.state.replaceAll('_', ' ')}. Hashes require explicit algorithm labels; no indicator was resolved or reputation-checked.`);
+        const supplied = report.distributionContext;
+        if (supplied)
+            lines.push(`Analyst-declared distribution: ${supplied.channel} · ${supplied.sourceLabel} · observed ${supplied.observedAt ?? 'unknown'}`, `  Reference ${supplied.reference ?? 'not supplied'} · observer ${supplied.observerLabel ?? 'unknown'} · vantage ${supplied.vantageLabel ?? 'unknown'}`, 'Distribution, observation time and vantage are supplied claims, not verified capture conditions or independent collection.');
+        const selected = report.selectedEvidence;
+        if (selected) {
+            lines.push(`Deliberately selected phone groups: ${selected.phones.length}. Original spans use zero-based, end-exclusive UTF-16 code units.`);
+            lines.push(`Phone extraction coverage: ${selected.phoneCoverage.state.replaceAll('_', ' ')}; ${selected.phoneCoverage.candidatesShown} transient candidates shown, ${selected.phoneCoverage.candidatesReviewed} candidate runs reviewed.`);
+            for (const phone of selected.phones) {
+                lines.push(`  ${phone.canonical ?? 'No canonical number'} · ${phone.state.replaceAll('_', ' ')} · declared ${phone.declaration.role.replaceAll('_', ' ')} · ${phone.declaration.basis.replaceAll('_', ' ')} · country context ${phone.declaration.countryCallingCode ?? 'unknown'}`, `  Source ${phone.declaration.sourceLabel}; declared observation ${phone.declaration.observedAt ?? 'unknown'}; input ${selected.sourceDigestSha256}`);
+                for (const occurrence of phone.occurrences)
+                    lines.push(`    ${JSON.stringify(occurrence.original)} · [${occurrence.start}, ${occurrence.end})${phone.extension ? ` · separate extension ${phone.extension}` : ''}`);
+            }
+            const pair = selected.destinationPair;
+            if (pair)
+                lines.push(`Supplied destination pair: ${pair.state.replaceAll('_', ' ')} · displayed ${pair.displayed.hostname ?? pair.displayed.state} · destination ${pair.destination.hostname ?? pair.destination.state}`, `  Displayed source ${pair.displayedDeclaration.sourceLabel}; declared ${pair.displayedDeclaration.observedAt ?? 'unknown'}; ${pair.displayedDeclaration.basis}`, `  Destination role ${pair.destinationDeclaration.role}; source ${pair.destinationDeclaration.sourceLabel}; declared ${pair.destinationDeclaration.observedAt ?? 'unknown'}; ${pair.destinationDeclaration.basis}`);
+            lines.push(...selected.limitations);
+        }
+    }
     if (report.actionHints.length)
         lines.push(`Review wording: ${report.actionHints.map(value => value.replaceAll('_', ' ')).join(', ')}`);
     if (report.documentReview) {
@@ -70,7 +94,7 @@ export function formatMessageIntake(report) {
         lines.push(`Partial analysis: ${report.coverage.boundsReached.join('; ')}`);
     if (report.source.kind === 'qr' && !report.coverage.reviewedParts)
         lines.push('No QR text was decoded. This does not establish that the image contains no QR symbol.');
-    lines.push('Exact paths, queries, fragments and original message content are not included. Link relationships and authorisation parameters are supplied claims, not proof of a completed redirect or account compromise.');
+    lines.push('Exact paths, queries, fragments and surrounding message content are not included. Only deliberately selected phone substrings can be retained. Link relationships and authorisation parameters are supplied claims, not proof of a completed redirect or account compromise.');
     return `${lines.join('\n')}\n`;
 }
 export async function runIntakeCommand(args, dependencies, context) {
@@ -95,11 +119,27 @@ export async function runIntakeCommand(args, dependencies, context) {
                 throw new CliUsageError(cause.message);
             throw cause;
         }
-        const report = { ...result.report, authenticationReview, identityRecovery: reviewIdentityIncident({ reportedActions: args.reportedActions }) };
+        let report = { ...result.report, authenticationReview, identityRecovery: reviewIdentityIncident({ reportedActions: args.reportedActions }) };
+        if (args.intakeContextSource) {
+            if (args.intakeContextSource === '-')
+                throw new CliUsageError('Distribution context requires a separate selected file, not stdin.');
+            report = applyIntakeContextInput({ ...result, report }, await context.readInput(args.intakeContextSource, MAX_INTAKE_CONTEXT_BYTES, 'Intake context'));
+        }
         dependencies.signal?.throwIfAborted();
+        if (!args.quiet && result.phoneReview && (result.phoneReview.candidates.length || result.phoneReview.state === 'partial')) {
+            const phones = result.phoneReview;
+            context.writeStderr([
+                `Transient phone candidates: ${phones.candidates.length}; coverage ${phones.state}. Values are omitted until explicitly selected.`,
+                `Full source digest: ${phones.sourceDigestSha256}`,
+                ...phones.candidates.map(candidate => `${candidate.id}: UTF-16 span [${candidate.start}, ${candidate.end}) · ${candidate.state.replaceAll('_', ' ')}`),
+                'Review these spans in the original plaintext. Use --intake-context with version 2, review.sourceDigestSha256, and review.phones entries containing start, end and an explicit declaration. Offsets are zero-based UTF-16 code units, end exclusive; retain BOMs and supplementary characters when counting.',
+                'Only selected values enter the private report. Public/trusted Case summaries and STIX/MISP mappings omit phone values.',
+                '',
+            ].join('\n'));
+        }
         if (!args.quiet)
             context.writeStdout(args.output === 'json' ? formatJsonDocument(report) : context.terminal(formatMessageIntake(report), args.color));
-        return args.strictExit && report.coverage.state === 'partial' ? EXIT_CODES.PARTIAL_FAILURE : EXIT_CODES.SUCCESS;
+        return args.strictExit && (report.coverage.state === 'partial' || result.phoneReview?.state === 'partial') ? EXIT_CODES.PARTIAL_FAILURE : EXIT_CODES.SUCCESS;
     }
     finally {
         bytes.fill(0);

package/cli/investigation-artifacts.mjs

@@ -10,7 +10,7 @@ import { validateLookupEvidenceArtifactStructure } from "./artifact-validation/l
 import { CLI_DISCOVERY_SCAN_SCHEMA, CLI_DISCOVERY_SCAN_VERSION } from "./discovery-scan.mjs";
 import { CLI_DISCOVER_SCHEMA, CLI_DISCOVER_SCHEMA_VERSION, CLI_POSTURE_SCHEMA, CLI_POSTURE_SCHEMA_VERSION, CLI_CT_SEARCH_SCHEMA, CLI_CT_SEARCH_SCHEMA_VERSION, CLI_COMPARE_SCHEMA, CLI_COMPARE_SCHEMA_VERSION, } from "./formatters/json.mjs";
 import { CLI_LOOKUP_BRIEF_SCHEMA, CLI_LOOKUP_BRIEF_VERSION } from "../packages/contracts/cli-lookup-brief.mjs";
-import { EXTERNAL_FINDINGS_SCHEMA, EXTERNAL_FINDINGS_VERSION, parseExternalFindingsDocument } from "../packages/interchange/external-findings-import.mjs";
+import { EXTERNAL_FINDINGS_SCHEMA, parseExternalFindingsDocument } from "../packages/interchange/external-findings-import.mjs";
 import { SOURCE_RELIABILITY_REPORT_SCHEMA, SOURCE_RELIABILITY_REPORT_VERSION } from "./source-reliability.mjs";
 import { CLI_CASE_PACK_SCHEMA, CLI_CASE_PACK_VERSION, verifyCliCasePack } from "./case-pack.mjs";
 import { SHARING_REVIEW_SCHEMA, SHARING_REVIEW_VERSION } from "./sharing-review.mjs";
@@ -59,8 +59,7 @@ export function validateWorkflowResult(step, result, retained) {
             break;
         case 'ct-intake':
             schema = EXTERNAL_FINDINGS_SCHEMA;
-            version = EXTERNAL_FINDINGS_VERSION;
-            parseExternalFindingsDocument(value);
+            version = parseExternalFindingsDocument(value).schemaVersion;
             break;
         case 'brief':
             schema = CLI_LOOKUP_BRIEF_SCHEMA;

package/cli/investigation-package-review.mjs

@@ -74,6 +74,7 @@ export async function verifyOfflineInvestigationPackage(input, passphrase) {
         }
         entries.push({ id: reviewed.entry.id, byteLength: reviewed.entry.byteLength,
             mediaType: 'mediaType' in reviewed.entry ? reviewed.entry.mediaType : 'application/json',
+            imageDerivation: 'imageDerivation' in reviewed.entry ? reviewed.entry.imageDerivation : null,
             state, identity: reviewed.state === 'identity_verified' ? 'verified' : 'failed', verification, issue });
     }
     const complete = entries.every((entry) => entry.state === 'admitted' || entry.state === 'opaque')
@@ -97,6 +98,7 @@ export async function verifyOfflineInvestigationPackage(input, passphrase) {
             'Capture attachment checks bind selected bytes to the capture manifest declaration, not to a trusted publisher or real website observation.',
             'Case-file checks match original references to other verified package bytes by length and digest, not by filename or claimed source. Missing originals make the package partial; no file is fetched or imported.',
             'Source declarations and packaging times are not authenticated. Signatures and timestamp tokens require their own verification and trust decisions.',
+            'Image derivation declares the immediate parent fingerprint and editing operations, not proof of transformation or complete redaction. Parent bytes are optional; missing declarations leave editing history unknown.',
             'This command does not import, overwrite or collect evidence. Unchanged bytes and valid source structure do not establish factual accuracy, currentness or safe sharing.',
         ]),
     });

package/cli/local-mmdb-review.mjs

@@ -31,26 +31,33 @@ function names(value) {
     const source = record(value);
     return boundedText(source.en, 120);
 }
-async function readStableMmdb(databasePath, openFile = open) {
+async function readStableMmdb(databasePath, openFile = open, signal) {
     let handle = null;
+    let database = null;
     try {
+        signal?.throwIfAborted();
         const resolvedPath = await realpath(databasePath);
+        signal?.throwIfAborted();
         handle = await openFile(resolvedPath, fsConstants.O_RDONLY | fsConstants.O_NONBLOCK | fsConstants.O_NOFOLLOW);
+        signal?.throwIfAborted();
         const before = await handle.stat();
+        signal?.throwIfAborted();
         if (!before.isFile() || before.size <= 0 || before.size > MAX_LOCAL_MMDB_BYTES) {
             throw new CliUsageError(`The supplied MMDB must be a file no larger than ${MAX_LOCAL_MMDB_BYTES} bytes.`);
         }
         // Dedicated backing storage can be transferred without copying a pooled
         // buffer or exposing bytes outside the stable file's exact length.
-        const database = Buffer.allocUnsafeSlow(before.size);
+        database = Buffer.allocUnsafeSlow(before.size);
         let offset = 0;
         while (offset < database.length) {
             const { bytesRead } = await handle.read(database, offset, database.length - offset, offset);
+            signal?.throwIfAborted();
             if (bytesRead === 0)
                 break;
             offset += bytesRead;
         }
         const after = await handle.stat();
+        signal?.throwIfAborted();
         if (offset !== database.length
             || before.dev !== after.dev
             || before.ino !== after.ino
@@ -62,6 +69,8 @@ async function readStableMmdb(databasePath, openFile = open) {
         return database;
     }
     catch (cause) {
+        database?.fill(0);
+        signal?.throwIfAborted();
         if (cause instanceof CliUsageError)
             throw cause;
         throw new CliUsageError('The supplied MMDB file could not be read.');
@@ -238,11 +247,17 @@ if (!isMainThread && parentPort && record(workerData).kind === LOCAL_MMDB_WORKER
 /** One disposable worker pre-empts the existing synchronous reader. It is not
  * a sandbox and never receives a database path or inherited environment. */
 export async function reviewLocalMmdb(input, databasePath, checkedAt = new Date().toISOString(), dependencies = {}) {
+    const { signal } = dependencies;
+    signal?.throwIfAborted();
     const query = prepareQuery(input, checkedAt);
     const deadlineMs = dependencies.deadlineMs ?? LOCAL_MMDB_REVIEW_DEADLINE_MS;
     if (!Number.isSafeInteger(deadlineMs) || deadlineMs <= 0 || deadlineMs > LOCAL_MMDB_REVIEW_DEADLINE_MS)
         throw new CliUsageError('Invalid local database processing deadline.');
-    const database = await readStableMmdb(databasePath, dependencies.openFile);
+    const database = await readStableMmdb(databasePath, dependencies.openFile, signal);
+    if (signal?.aborted) {
+        database.fill(0);
+        signal.throwIfAborted();
+    }
     const identity = { sha256: createHash('sha256').update(database).digest('hex'), byteLength: database.length };
     const options = { workerData: { kind: LOCAL_MMDB_WORKER_KIND, query, bytes: database, identity },
         transferList: [database.buffer], env: {}, execArgv: [], stdout: true, stderr: true,
@@ -254,6 +269,7 @@ export async function reviewLocalMmdb(input, databasePath, checkedAt = new Date(
     catch {
         if (database.byteLength)
             database.fill(0);
+        signal?.throwIfAborted();
         if (query.version === 2)
             return freezeResult(currentResult(query, identity, { metadata: null, ageDays: null, reason: 'invalid_metadata' }, 'processing_unavailable'));
         throw new CliUsageError('The supplied database could not be reviewed within its format and processing bounds.');
@@ -268,17 +284,24 @@ export async function reviewLocalMmdb(input, databasePath, checkedAt = new Date(
                     return;
                 settled = true;
                 clearTimeout(timer);
-                if (result)
+                signal?.removeEventListener('abort', onAbort);
+                if (signal?.aborted)
+                    reject(signal.reason);
+                else if (result)
                     resolve(freezeResult(result));
                 else if (query.version === 2)
                     resolve(freezeResult(currentResult(query, identity, { metadata: null, ageDays: null, reason: 'invalid_metadata' }, reason)));
                 else
                     reject(new CliUsageError('The supplied database could not be reviewed within its format and processing bounds.'));
             };
+            const onAbort = () => finish();
             const timer = setTimeout(() => finish(undefined, 'processing_deadline'), deadlineMs);
             worker.once('message', (reply) => reply && 'result' in reply ? finish(reply.result) : finish());
             worker.once('error', () => finish());
             worker.once('exit', () => finish());
+            signal?.addEventListener('abort', onAbort, { once: true });
+            if (signal?.aborted)
+                onAbort();
         });
     }
     finally {

package/cli/lookup-command-runner.mjs

@@ -110,6 +110,7 @@ async function runLookupCommand(args, dependencies, context) {
             const save = dependencies.writePrivateFile || writePrivateFile;
             await save(args.saveLookup, serializeCliLookupDocument(document), {
                 existingFileMessage: 'Saved Lookup file already exists. Choose a new --save-lookup path or remove the existing file explicitly.',
+                beforePublish: async () => { dependencies.signal?.throwIfAborted(); },
             });
             context.writeStderr('Saved the completed private Lookup JSON. It can contain raw public registry and WHOIS responses plus target and collection context; review it before sharing.\n');
         }

package/cli/offline-evidence-review.mjs

@@ -1,7 +1,7 @@
 import { Buffer } from 'node:buffer';
 import { scanBoundedJson } from "../packages/analysis/bounded-json.mjs";
 import { CONTEXT_INPUT_SCHEMAS, reviewContextInput } from "../packages/investigation/context-review.mjs";
-import { CONTEXT_REVIEW_KINDS } from "../packages/contracts/context-review.mjs";
+import { CONTEXT_REVIEW_KINDS, DOMAIN_HISTORY_INPUT_SCHEMA, DOMAIN_HISTORY_INPUT_VERSION } from "../packages/contracts/context-review.mjs";
 import { normalizeEncryptedDnsAdapter, planEncryptedDnsQuery, } from "../lib/encrypted-dns-contract.mjs";
 import { validateDnssecEvidence } from "../lib/dnssec-evidence-validation.mjs";
 import { reviewDomainChange } from "../lib/domain-change-review.mjs";
@@ -18,6 +18,10 @@ import { compareTrustStoreEvidence } from "../lib/trust-store-comparison.mjs";
 import { CliUsageError } from "./errors.mjs";
 import { safeTerminalValue } from "./formatters/terminal.mjs";
 import { LOCAL_MMDB_QUERY_SCHEMA, LOCAL_MMDB_QUERY_VERSION, LOCAL_MMDB_REVIEW_SCHEMA, LOCAL_MMDB_REVIEW_VERSION, reviewLocalMmdb } from "./local-mmdb-review.mjs";
+import { INFRASTRUCTURE_OBSERVATION_SCHEMA, MAX_INFRASTRUCTURE_OBSERVATION_BYTES, infrastructureObservationFacts, compareInfrastructureObservations } from "../packages/investigation/infrastructure-observation.mjs";
+import { exact } from "../packages/evidence/artifact-structure.mjs";
+import { INFRASTRUCTURE_COMPARISON_INPUT_SCHEMA, MAX_INFRASTRUCTURE_COMPARISON_INPUT_BYTES } from "../packages/contracts/external-observation-interchange.mjs";
+import { CASE_CONTAINMENT_INPUT_SCHEMA, readCaseContainmentInput, formatCaseContainmentHandoff } from "../packages/cases/case-containment-handoff.mjs";
 const OFFLINE_EVIDENCE_REVIEW_SCHEMA = 'whoisleuth.cli.offline-evidence-review';
 const OFFLINE_EVIDENCE_REVIEW_VERSION = 1;
 const MAX_OFFLINE_EVIDENCE_INPUT_BYTES = 16 * 1024 * 1024;
@@ -46,7 +50,8 @@ function parseInput(value) {
     }
     const document = record(parsed);
     if (typeof document.schema !== 'string' || document.version !== 1
-        && !(document.schema === LOCAL_MMDB_QUERY_SCHEMA && document.version === LOCAL_MMDB_QUERY_VERSION)) {
+        && !(document.schema === LOCAL_MMDB_QUERY_SCHEMA && document.version === LOCAL_MMDB_QUERY_VERSION)
+        && !(document.schema === DOMAIN_HISTORY_INPUT_SCHEMA && document.version === DOMAIN_HISTORY_INPUT_VERSION)) {
         throw new CliUsageError('Offline evidence review requires a supported versioned input schema.');
     }
     return document;
@@ -57,7 +62,27 @@ function buildOfflineEvidenceReview(value, generatedAt = new Date().toISOString(
         throw new CliUsageError('Local MMDB review requires --mmdb <database-file>.');
     let kind;
     let result;
-    if (CONTEXT_INPUT_SCHEMAS.includes(input.schema)) {
+    if (input.schema === CASE_CONTAINMENT_INPUT_SCHEMA) {
+        kind = 'internal_containment';
+        result = readCaseContainmentInput(input, generatedAt);
+    }
+    else if (input.schema === INFRASTRUCTURE_OBSERVATION_SCHEMA) {
+        if (typeof value === 'string' && new TextEncoder().encode(value).byteLength > MAX_INFRASTRUCTURE_OBSERVATION_BYTES)
+            throw new TypeError('Infrastructure snapshot input exceeds its byte bound.');
+        kind = 'infrastructure';
+        const retained = infrastructureObservationFacts(input);
+        result = { ...retained, state: retained.snapshot.coverage.state === 'complete' && !retained.snapshot.coverage.truncated ? 'complete' : 'partial' };
+    }
+    else if (input.schema === INFRASTRUCTURE_COMPARISON_INPUT_SCHEMA) {
+        if (typeof value === 'string' && new TextEncoder().encode(value).byteLength > MAX_INFRASTRUCTURE_COMPARISON_INPUT_BYTES)
+            throw new TypeError('Infrastructure comparison input exceeds its byte bound.');
+        const pair = exact(input, ['schema', 'version', 'earlier', 'later'], 'Infrastructure comparison input');
+        if (new TextEncoder().encode(JSON.stringify(pair)).byteLength > MAX_INFRASTRUCTURE_COMPARISON_INPUT_BYTES)
+            throw new TypeError('Infrastructure comparison input exceeds its byte bound.');
+        kind = 'infrastructure_comparison';
+        result = compareInfrastructureObservations(pair.earlier, pair.later);
+    }
+    else if (CONTEXT_INPUT_SCHEMAS.includes(input.schema)) {
         const review = reviewContextInput(input, generatedAt);
         kind = review.kind;
         result = review;
@@ -173,13 +198,15 @@ async function buildOfflineEvidenceReviewWithLocalResources(value, generatedAt =
         version: OFFLINE_EVIDENCE_REVIEW_VERSION,
         generatedAt,
         kind: 'geoip',
-        result: await reviewLocalMmdb(input, options.mmdbPath, generatedAt),
+        result: await reviewLocalMmdb(input, options.mmdbPath, generatedAt, options.signal ? { signal: options.signal } : {}),
         limitations: Object.freeze([
             'The review is local and uses only the supplied query metadata and analyst-supplied database. It does not transmit the address or refresh the database.',
         ]),
     });
 }
 function formatOfflineEvidenceReview(document) {
+    if (document.kind === 'internal_containment')
+        return formatCaseContainmentHandoff(document.result);
     const result = record(document.result);
     if (document.kind === 'geoip' && result.schema === LOCAL_MMDB_REVIEW_SCHEMA && result.version !== LOCAL_MMDB_REVIEW_VERSION) {
         throw new CliUsageError('Offline evidence review does not support this MMDB result version.');
@@ -204,7 +231,26 @@ function formatOfflineEvidenceReview(document) {
         `Kind   ${document.kind.replaceAll('_', ' ')}`,
         `State  ${state.replaceAll('_', ' ')}`,
     ];
-    if (CONTEXT_REVIEW_KINDS.includes(document.kind)) {
+    if (document.kind === 'infrastructure') {
+        const snapshot = record(result.snapshot), scope = record(snapshot.scope), coverage = record(snapshot.coverage);
+        lines.push(`Snapshot ${safeTerminalValue(snapshot.id, '')} · ${safeTerminalValue(snapshot.target, '')} · ${safeTerminalValue(snapshot.observedAt, '')}`, `Coverage ${safeTerminalValue(coverage.state, 'unknown')} · ${safeTerminalValue(coverage.detail, '')}`, `Selected hosts ${listLength(scope.hostnames)}`);
+        for (const item of Array.isArray(result.facts) ? result.facts : []) {
+            const row = record(item), source = record(row.source);
+            lines.push(`${safeTerminalValue(row.hostname, '')} · ${safeTerminalValue(row.family, '')}: ${safeTerminalValue(row.value, '')} · ${safeTerminalValue(source.name, '')} (${safeTerminalValue(source.evidenceClass, '')}) · ${safeTerminalValue(row.observedAt, '')}`);
+        }
+        lines.push('Wildcard patterns are not enumerated hosts. DNS failure, missing values and history do not establish current absence. No requests or watchlist changes were made.');
+    }
+    else if (document.kind === 'infrastructure_comparison') {
+        for (const item of Array.isArray(result.rows) ? result.rows : []) {
+            const row = record(item), source = record(row.source);
+            // Bound individual identities, not the combined label: a valid DNS query
+            // and owner may each occupy all 253 hostname characters.
+            const cohort = Object.entries(record(row.cohort)).map(([key, value]) => `${safeTerminalValue(key)}=${safeTerminalValue(value, '', 253)}`).join(' · ');
+            const times = (value) => Array.isArray(value) ? value.map(time => safeTerminalValue(time, '')).join(', ') : '';
+            lines.push(`${safeTerminalValue(row.hostname, '')} · ${safeTerminalValue(row.family, '')} · ${safeTerminalValue(source.name, '')} (${safeTerminalValue(source.evidenceClass, '')}) · ${safeTerminalValue(row.state, '')}`, `  Cohort: ${cohort}`, `  Earlier observations: ${times(row.beforeTimes)}; later observations: ${times(row.afterTimes)}`, `  ${safeTerminalValue(JSON.stringify(row.before), '')} → ${safeTerminalValue(JSON.stringify(row.after), '')}`, `  ${safeTerminalValue(row.detail, '')}`);
+        }
+    }
+    else if (CONTEXT_REVIEW_KINDS.includes(document.kind)) {
         lines.push(safeTerminalValue(result.summary, ''));
         for (const item of Array.isArray(result.observations) ? result.observations : []) {
             const row = record(item);

package/cli/review-arguments.mjs

@@ -45,10 +45,10 @@ function parseCaseArguments(parsed) {
     if (operation === 'note' ? text === null && !noteSource : text !== null || noteSource !== null) {
         throw new CliUsageError('Only case note accepts and requires --text or --note-file.');
     }
-    if (['pin', 'link', 'withdraw-link', 'assess', 'recheck'].includes(operation)
+    if (['pin', 'link', 'withdraw-link', 'assess', 'recheck', 'incident-link', 'action', 'action-event', 'recheck-question', 'close-object'].includes(operation)
         ? !inputSource
         : inputSource !== null) {
-        throw new CliUsageError('Only case pin, link, withdraw-link, assess and recheck accept and require --input.');
+        throw new CliUsageError('This Case mutation requires --input; show, open and note do not accept it.');
     }
     if (expectedFileDigest !== null && (!source || !/^sha256:[a-f0-9]{64}$/u.test(expectedFileDigest))) {
         throw new CliUsageError('--expect-file-digest requires a source file and sha256:<64 lowercase hexadecimal characters>.');
@@ -95,6 +95,7 @@ export const REVIEW_ARGUMENT_PARSERS = Object.freeze({
         action: 'intake',
         kind: parsed.positionalValue('kind'),
         reportedActions: parsed.optionValues('--reported-action'),
+        ...(parsed.hasOption('--intake-context') ? { intakeContextSource: parsed.optionValue('--intake-context') } : {}),
         ...(parsed.hasOption('--trusted-auth-header')
             ? { trustedAuthHeaders: parsed.optionValues('--trusted-auth-header') }
             : {}),

package/cli/review-command-definitions.mjs

@@ -2,6 +2,8 @@ import { CASE_SCHEMA_VERSION, CLI_CASE_PACK_INPUT_CASE_VERSIONS, MAX_CASE_STORE_
 import { MESSAGE_INTAKE_KINDS, MESSAGE_INTAKE_SCHEMA } from "../packages/contracts/message-intake.mjs";
 import { IDENTITY_EVENTS_INPUT_SCHEMA } from "../packages/contracts/identity-events.mjs";
 import { CONTEXT_INPUT_SCHEMAS, CONTEXT_REVIEW_SCHEMA } from "../packages/contracts/context-review.mjs";
+import { CASE_CONTAINMENT_INPUT_SCHEMA, CASE_CONTAINMENT_HANDOFF_SCHEMA } from "../packages/cases/case-containment-handoff.mjs";
+import { INTAKE_CONTEXT_SCHEMA } from "../packages/investigation/intake-context.mjs";
 import { MANAGED_INDICATOR_SET_SCHEMA, MAX_MANAGED_INDICATOR_SET_BYTES, MAX_MANAGED_INDICATOR_PLAN_BYTES } from "../packages/contracts/analyst-interchange.mjs";
 import { CLI_CASE_OPERATIONS, CLI_INDICATOR_OPERATIONS, positional, OPTIONAL_FILE_POSITIONAL, constraint, EMPTY_CONSTRAINTS, commandSeed } from "./command-definition.mjs";
 export const REVIEW_COMMAND_DEFINITIONS = Object.freeze({
@@ -154,23 +156,23 @@ export const REVIEW_COMMAND_DEFINITIONS = Object.freeze({
     }),
     intake: commandSeed({
         reference: {
-            description: 'Review message identities, document links, QR destinations, HTTP archives or selected identity events locally.',
+            description: 'Review selected messages, indicators, document links, QR destinations, HTTP archives or identity events locally. Plain text offers phone candidates; --intake-context adds explicit selections and source declarations.',
             example: 'whoisleuth intake email message.eml --json',
-            boundary: 'Offline only: no destination, embedded command or QR payload is opened or executed. Output omits original bodies, subjects, address local parts, URL paths, queries and fragments. Authentication headers remain attributed claims. Selected PDF and DOCX review retains part identities and extraction coverage; embedded raster QR support does not imply complete rendered-page review. HAR retains minimised request order and timings, never replay authority, headers, cookies or bodies. Use --strict-exit to return 4 for partial coverage.',
+            boundary: 'Offline only: no destination, embedded command, phone number or QR payload is opened, contacted or executed. Output omits original bodies, subjects, address local parts, URL paths, queries and fragments. Literal IPs and labelled hashes are bounded text observations, not lookup targets or verdicts; headers, URL contents, QR, HAR and identity-event fields are not scanned for them. Plain-text phone discovery writes only counts, source digest, ranges and status to stderr; --quiet suppresses it. Optional --intake-context reads one separate file up to 8 KiB, not stdin. Version 1 carries distribution declarations; version 2 can also bind explicit phone selections and a supplied destination pair to the exact input digest. Selected phone strings and source declarations enter output; unselected candidates and exact private URLs do not. Authentication headers remain attributed claims. Selected PDF and DOCX review retains part identities and extraction coverage; embedded raster QR support does not imply complete rendered-page review. HAR retains minimised request order and timings, never replay authority, headers, cookies or bodies. Use --strict-exit to return 4 for partial coverage.',
         },
-        collection: { scope: 'Reads one selected text, MIME email, calendar, PNG, PDF, DOCX, HAR or identity-event JSON file. No collection or automatic Case write.' },
+        collection: { scope: 'Reads one selected text, MIME email, calendar, PNG, PDF, DOCX, HAR or identity-event JSON file and, only with --intake-context, one bounded declaration/selection file. No collection or automatic Case write.' },
         summary: 'Review selected files and identity events offline',
-        options: ['--json', '--reported-action', '--trusted-auth-header', '--strict-exit', '--quiet', '--no-color'],
+        options: ['--json', '--reported-action', '--trusted-auth-header', '--intake-context', '--strict-exit', '--quiet', '--no-color'],
         positionals: Object.freeze([positional('kind', 'enum', 1, 1, MESSAGE_INTAKE_KINDS), positional('source', 'file', 0, 1, [], 'argv_or_stdin')]),
         constraints: EMPTY_CONSTRAINTS, handlerOwner: 'review', networkEffect: 'offline', common: true,
-        schemaIdentifiers: Object.freeze([MESSAGE_INTAKE_SCHEMA, IDENTITY_EVENTS_INPUT_SCHEMA]), primaryArtefacts: Object.freeze([]),
+        schemaIdentifiers: Object.freeze([MESSAGE_INTAKE_SCHEMA, INTAKE_CONTEXT_SCHEMA, IDENTITY_EVENTS_INPUT_SCHEMA]), primaryArtefacts: Object.freeze([]),
         planSupport: false, additionalOutputFormats: Object.freeze([]), bootstrapProfile: 'allowed',
     }),
     "review-evidence": commandSeed({
         reference: {
-            description: 'Review versioned protocol evidence, incident sequences, domain history, platform objects, storefronts or connector configuration offline.',
+            description: 'Review versioned protocol evidence, source-qualified infrastructure snapshots/comparisons, incident sequences, domain history, platform objects, storefronts, connector configuration or an explicitly selected internal containment handoff offline.',
             example: 'whoisleuth review-evidence domain-change.json --json --strict-exit',
-            boundary: 'The command reads only the supplied document and, with --mmdb, one explicitly selected local database up to 512 MiB. MMDB parsing and lookup run in one disposable worker with a ten-second processing deadline and an 8 KiB result limit. Version-2 MMDB queries require a justified age policy; unavailable or partial current reviews return 4 under --strict-exit. Historical version-1 MMDB queries preserve their output without freshness admission. No database is bundled, downloaded, updated or transmitted. It performs no DNS, RDAP, BGP, GeoIP-provider, TLS, HTTP, certificate-authority, or SMTP request.',
+            boundary: 'The command reads only the supplied document and, with --mmdb, one explicitly selected local database up to 512 MiB. MMDB parsing and lookup run in one disposable worker with a ten-second processing deadline and an 8 KiB result limit. Version-2 MMDB queries require a justified age policy; unavailable or partial current reviews return 4 under --strict-exit. Historical version-1 MMDB queries preserve their output without freshness admission. Domain-history v2 accepts explicit source-linked registration boundaries; v1 retains its original semantics. Internal containment selects retained next-step assertions and supporting pins after explicit audience-disclosure review; it does not change their state or execute controls. No database is bundled, downloaded, updated or transmitted. It performs no DNS, RDAP, BGP, GeoIP-provider, TLS, HTTP, certificate-authority, or SMTP request.',
         },
         collection: { scope: 'Reads one bounded versioned evidence or request-planning document and, only with --mmdb, one selected bounded local database. Performs no collection.' },
         summary: 'Review supplied evidence offline',
@@ -182,6 +184,8 @@ export const REVIEW_COMMAND_DEFINITIONS = Object.freeze({
         common: true,
         schemaIdentifiers: Object.freeze([
             CONTEXT_REVIEW_SCHEMA,
+            CASE_CONTAINMENT_INPUT_SCHEMA,
+            CASE_CONTAINMENT_HANDOFF_SCHEMA,
             ...CONTEXT_INPUT_SCHEMAS,
             'whoisleuth.cli.offline-evidence-review',
             'whoisleuth.rdap-search-input',
@@ -192,6 +196,8 @@ export const REVIEW_COMMAND_DEFINITIONS = Object.freeze({
             'whoisleuth.local-mmdb-query',
             'whoisleuth.local-mmdb-review',
             'whoisleuth.encrypted-dns-plan-input',
+            'whoisleuth.infrastructure-observation',
+            'whoisleuth.infrastructure-comparison.input',
         ]),
         primaryArtefacts: Object.freeze([]),
         planSupport: false,
@@ -220,7 +226,7 @@ export const REVIEW_COMMAND_DEFINITIONS = Object.freeze({
     }),
     case: commandSeed({
         reference: {
-            description: 'Show or open a local Case, append a note or evidence pin, link evidence, withdraw a link, record an assessment, or retain an offline recheck. Use --input for pin, link, withdraw-link, assessment and recheck JSON; --text or --note-file for a note. Link input contains fromPinId, toPinId, kind (derived_from or shared_source), and basis. Withdrawal input contains id and reason. Mutations require --output and always write the complete current Case export.',
+            description: 'Show or open a local Case, append a note or evidence pin, link evidence, record an assessment or offline recheck, retain an incident-link, create an action, append an action-event, save a recheck-question, or close-object. JSON mutations use --input; notes use --text or --note-file. Link input contains fromPinId, toPinId, kind and basis. Action-event input contains id and transition. Explicit responseObjects bind an action; a typed objectOutcome requires an explicit affected subset on its event. Object closure never closes other objects or the Case. Mutations require --output and write the complete current Case export.',
             example: 'whoisleuth case open --domain example.test --output cases.json\n  whoisleuth case show cases.json\n  whoisleuth case note cases.json --text "Review the retained observation" --output cases.json --force',
             boundary: 'No database, browser launch, request or external report is created. Select --case-id when a file contains multiple Cases. Existing files require --force; --expect-file-digest sha256:<digest> additionally checks the exact file reviewed earlier. Source and output leases reject concurrent changes. Interrupted .workflow.lock files require deliberate inspection. Recheck records supplied observations; it does not collect them. Not reproduced requires an existing saved question, a complete observation and comparable conditions. Working exports include private analyst content and file references, not attached file bytes.',
         },

package/cli/review-command-runner.mjs

@@ -192,8 +192,9 @@ async function runOfflineEvidenceReviewCommand(args, dependencies, context) {
         ? await dependencies.readArtifactInput(args.source)
         : await context.readInput(args.source, MAX_OFFLINE_EVIDENCE_INPUT_BYTES, 'Offline evidence input'), 'offline evidence input', 'review-evidence requires one JSON file or a document on stdin.');
     const document = args.mmdbSource
-        ? await buildOfflineEvidenceReviewWithLocalResources(input, context.now(), { mmdbPath: args.mmdbSource })
+        ? await buildOfflineEvidenceReviewWithLocalResources(input, context.now(), { mmdbPath: args.mmdbSource, ...(dependencies.signal ? { signal: dependencies.signal } : {}) })
         : buildOfflineEvidenceReview(input, context.now());
+    dependencies.signal?.throwIfAborted();
     writeReviewReport(context, args, document, formatOfflineEvidenceReview);
     if (args.strictExit) {
         const result = document.result && typeof document.result === 'object' && !Array.isArray(document.result)
@@ -205,9 +206,11 @@ async function runOfflineEvidenceReviewCommand(args, dependencies, context) {
         const zoneMismatch = document.kind === 'zone_intent' && (result.complete !== true
             || (result.counts && typeof result.counts === 'object' && !Array.isArray(result.counts)
                 && ['different', 'missing', 'unexpected', 'incomplete'].some((key) => Number(result.counts[key]) > 0)));
-        const contextPartial = CONTEXT_REVIEW_KINDS.includes(document.kind) && result.state === 'partial';
+        const contextPartial = (CONTEXT_REVIEW_KINDS.includes(document.kind) || document.kind === 'internal_containment') && result.state === 'partial';
         const mmdbIncomplete = result.schema === LOCAL_MMDB_REVIEW_SCHEMA && result.version === LOCAL_MMDB_REVIEW_VERSION && result.completeness !== 'complete';
-        if (gate?.pass === false || zoneMismatch || contextPartial || mmdbIncomplete)
+        const infrastructureIncomplete = document.kind === 'infrastructure' ? result.state !== 'complete'
+            : document.kind === 'infrastructure_comparison' && result.state !== 'compared';
+        if (gate?.pass === false || zoneMismatch || contextPartial || mmdbIncomplete || infrastructureIncomplete)
             return EXIT_CODES.PARTIAL_FAILURE;
     }
     return EXIT_CODES.SUCCESS;

package/cli/risk-calibration.mjs

@@ -5,7 +5,7 @@ import { scanBoundedJson } from "../packages/analysis/bounded-json.mjs";
 import { canonicalRegistrableDomain } from "../packages/analysis/registrable-domain.mjs";
 import { ANALYST_REVIEW_REASON_VALUES, analystInteroperabilityTags } from "../packages/analysis/analyst-taxonomy.mjs";
 import { buildRiskCalibrationSummaryReport, parseRiskCalibrationSummaryReport, RISK_CALIBRATION_SUMMARY_INTERPRETATION, RISK_CALIBRATION_SUMMARY_THRESHOLDS, } from "../packages/analysis/risk-calibration-summary.mjs";
-import { MAX_RISK_CALIBRATION_ACTIVITY_LENGTH, MAX_RISK_CALIBRATION_AVAILABILITY_LENGTH, MAX_RISK_CALIBRATION_DISPOSITION_LENGTH, MAX_RISK_CALIBRATION_DOMAIN_AGE_DAYS, MAX_RISK_CALIBRATION_DOMAIN_LENGTH, MAX_RISK_CALIBRATION_FINDING_CATEGORY_LENGTH, MAX_RISK_CALIBRATION_FINDINGS_PER_PROVIDER, MAX_RISK_CALIBRATION_INPUT_BYTES, MAX_RISK_CALIBRATION_JSON_CONTAINER_ITEMS, MAX_RISK_CALIBRATION_JSON_DEPTH, MAX_RISK_CALIBRATION_JSON_KEYS, MAX_RISK_CALIBRATION_JSON_VALUES, MAX_RISK_CALIBRATION_MUTATIONS, MAX_RISK_CALIBRATION_PROVIDER_ID_LENGTH, MAX_RISK_CALIBRATION_PROVIDER_STATE_LENGTH, MAX_RISK_CALIBRATION_PROVIDERS, MAX_RISK_CALIBRATION_RECORD_ID_LENGTH, MAX_RISK_CALIBRATION_RECORDS, MAX_RISK_CALIBRATION_REVIEW_REASON_LENGTH, MAX_RISK_CALIBRATION_SCAN_DEPTH_LENGTH, MAX_RISK_CALIBRATION_STRING_LENGTH, MAX_RISK_CALIBRATION_TIMESTAMP_LENGTH, RISK_CALIBRATION_DATASET_SCHEMA, RISK_CALIBRATION_DATASET_VERSION, RISK_CALIBRATION_REPORT_SCHEMA, RISK_CALIBRATION_REPORT_VERSION, RISK_CALIBRATION_DISPOSITIONS, serializeRiskCalibrationSnapshot, snapshotRiskCalibrationReportForSerialization, SUPPORTED_RISK_CALIBRATION_DATASET_VERSIONS, } from "../packages/contracts/risk-calibration.mjs";
+import { MAX_RISK_CALIBRATION_ACTIVITY_LENGTH, MAX_RISK_CALIBRATION_AVAILABILITY_LENGTH, MAX_RISK_CALIBRATION_DISPOSITION_LENGTH, MAX_RISK_CALIBRATION_DOMAIN_AGE_DAYS, MAX_RISK_CALIBRATION_DOMAIN_LENGTH, MAX_RISK_CALIBRATION_FINDING_CATEGORY_LENGTH, MAX_RISK_CALIBRATION_FINDINGS_PER_PROVIDER, MAX_RISK_CALIBRATION_INPUT_BYTES, MAX_RISK_CALIBRATION_JSON_CONTAINER_ITEMS, MAX_RISK_CALIBRATION_JSON_DEPTH, MAX_RISK_CALIBRATION_JSON_KEYS, MAX_RISK_CALIBRATION_JSON_VALUES, MAX_RISK_CALIBRATION_MUTATIONS, MAX_RISK_CALIBRATION_PROVIDER_ID_LENGTH, MAX_RISK_CALIBRATION_PROVIDER_STATE_LENGTH, MAX_RISK_CALIBRATION_PROVIDERS, MAX_RISK_CALIBRATION_RECORD_ID_LENGTH, MAX_RISK_CALIBRATION_RECORDS, MAX_RISK_CALIBRATION_REVIEW_REASON_LENGTH, MAX_RISK_CALIBRATION_SCAN_DEPTH_LENGTH, MAX_RISK_CALIBRATION_STRING_LENGTH, MAX_RISK_CALIBRATION_TIMESTAMP_LENGTH, RISK_CALIBRATION_DATASET_SCHEMA, RISK_CALIBRATION_REPORT_SCHEMA, RISK_CALIBRATION_REPORT_VERSION, RISK_CALIBRATION_DISPOSITIONS, serializeRiskCalibrationSnapshot, snapshotRiskCalibrationReportForSerialization, SUPPORTED_RISK_CALIBRATION_DATASET_VERSIONS, } from "../packages/contracts/risk-calibration.mjs";
 import { CliUsageError } from "./errors.mjs";
 import { RISK_MUTATION_TYPES } from "../packages/analysis/risk-scoring.mjs";
 import { THREAT_INTELLIGENCE_CONTRACT_VERSION, THREAT_INTELLIGENCE_ENVELOPE_VERSION, THREAT_INTELLIGENCE_SCHEMA, } from "../packages/analysis/threat-intelligence-types.mjs";
@@ -17,7 +17,7 @@ const AVAILABILITY_STATES = new Set(['registered', 'for_sale', 'expiring', 'avai
 const ACTIVITY_STATES = new Set(['active', 'parked', 'unreachable', 'no_site']);
 const BOOLEAN_FIELDS = [
     'faviconMatch', 'faviconNearMatch', 'reusesOfficialAssets', 'hasPasswordField',
-    'hasMx', 'hasSpf', 'hasDmarc', 'privacyProtected', 'hasExternalFormAction',
+    'hasMx', 'hasSpf', 'hasDmarc', 'privacyProtected', 'hasExternalFormAction', 'hasExternalPasswordForm',
     'idnReferenceMatch', 'pageBaselineMatch', 'hasActiveBrandProfile',
 ];
 const REVIEW_REASON_CODES = ANALYST_REVIEW_REASON_VALUES;
@@ -95,8 +95,10 @@ function projectThreatIntelligence(value, field) {
         }),
     };
 }
-function projectEvidence(value, field) {
+function projectEvidence(value, field, version) {
     const source = object(value, field);
+    if (version < 3 && Object.hasOwn(source, 'hasExternalPasswordForm'))
+        throw new CliUsageError(`${field}.hasExternalPasswordForm requires dataset version 3; historical inputs were not reinterpreted.`);
     const availability = boundedString(source.availability ?? source.state, `${field}.availability`, MAX_RISK_CALIBRATION_AVAILABILITY_LENGTH);
     if (!AVAILABILITY_STATES.has(availability))
         throw new CliUsageError(`${field}.availability is unsupported.`);
@@ -234,7 +236,7 @@ export function parseRiskCalibrationDataset(text) {
             domain,
             analystDisposition,
             ...(reviewReasonCode ? { reviewReasonCode } : {}),
-            evidence: projectEvidence(record.evidence, `${prefix}.evidence`),
+            evidence: projectEvidence(record.evidence, `${prefix}.evidence`, documentVersion),
         };
     });
     return {

package/cli/selected-input-worker.mjs

@@ -3,6 +3,8 @@ import { reviewSelectedInput } from "../packages/investigation/selected-input-re
 import { assertMessageBytes } from "../packages/investigation/intake-report.mjs";
 import { DOCUMENT_REVIEW_DEADLINE_MS } from "../packages/contracts/document-intake.mjs";
 import { MESSAGE_INTAKE_SCHEMA, MESSAGE_INTAKE_VERSION } from "../packages/contracts/message-intake.mjs";
+import { validateIntakeExtensions } from "../packages/investigation/intake-context.mjs";
+import { validatePhoneReview } from "../packages/investigation/intake-phones.mjs";
 if (!isMainThread && parentPort) {
     const port = parentPort, request = workerData;
     try {
@@ -45,8 +47,16 @@ export async function reviewSelectedInputInWorker(bytes, kind, reviewedAt, signa
             const abort = () => finish(undefined, new Error('Selected input review was cancelled. Nothing was saved.'));
             const timer = setTimeout(() => finish(undefined, new Error('Selected input review exceeded its processing deadline. Nothing was saved.')), DOCUMENT_REVIEW_DEADLINE_MS);
             worker.once('message', (reply) => {
-                if (reply && typeof reply === 'object' && 'result' in reply && reply.result?.report.schema === MESSAGE_INTAKE_SCHEMA && reply.result.report.schemaVersion === MESSAGE_INTAKE_VERSION)
-                    finish(reply.result);
+                if (reply && typeof reply === 'object' && 'result' in reply && reply.result?.report.schema === MESSAGE_INTAKE_SCHEMA && reply.result.report.schemaVersion === MESSAGE_INTAKE_VERSION) {
+                    try {
+                        validateIntakeExtensions(reply.result.report);
+                        validatePhoneReview(reply.result);
+                        finish(reply.result);
+                    }
+                    catch {
+                        finish(undefined, new Error('Selected input returned an unsupported review. Nothing was retained.'));
+                    }
+                }
                 else
                     finish();
             });

package/cli/support-command-runner.mjs

@@ -1,6 +1,6 @@
 import { REGISTRY_CAPABILITIES_VERSION, registryCapabilityFor } from "../lib/registry-capabilities.mjs";
 import { buildRiskCalibrationSummaryReport } from "../packages/analysis/risk-calibration-summary.mjs";
-import { explainRiskScore, explainRiskScoreV7, RISK_MODEL_VERSION, RISK_REVIEW_THRESHOLD } from "../packages/analysis/risk-scoring.mjs";
+import { explainRiskScore, explainRiskScoreV8, RISK_MODEL_VERSION, RISK_REVIEW_THRESHOLD } from "../packages/analysis/risk-scoring.mjs";
 import { buildCliCommandCatalogue, formatCliCommandCatalogue, selectCliCommands } from "./command-catalogue.mjs";
 import { CLI_COMMAND_REGISTRY, CLI_COMMANDS, COMMAND_COLLECTION, COMMAND_DETAILS, COMMAND_USAGE, } from "./command-reference.mjs";
 import { buildShellCompletion } from "./completion.mjs";
@@ -169,8 +169,8 @@ async function runRiskCalibrationCommand(args, dependencies, context) {
         modelVersion: dependencies.riskModelVersion || RISK_MODEL_VERSION,
         reviewThreshold: dependencies.riskReviewThreshold || RISK_REVIEW_THRESHOLD,
         ...(!dependencies.explainRiskScore ? {
-            previousModelVersion: 7,
-            explainPreviousRiskScore: explainRiskScoreV7,
+            previousModelVersion: 8,
+            explainPreviousRiskScore: explainRiskScoreV8,
         } : {}),
     });
     if (!args.quiet) {

package/cli/watchlist-review.mjs

@@ -0,0 +1,43 @@
+import { parseBoundedJson } from "../packages/analysis/bounded-json.mjs";
+import { applyCandidateWatchHandoff, planCandidateWatchHandoff, } from "../packages/workspace/candidate-watch-handoff.mjs";
+import { buildWatchlistExport, mergeWatchlistStores, } from "../packages/workspace/watchlist-store.mjs";
+import { MAX_WATCHLIST_IMPORT_BYTES } from "../packages/contracts/workspace-portability.mjs";
+import { ordinaryWorkspaceRecord } from "../packages/workspace/hostile-input.mjs";
+import { CANDIDATE_WATCH_INPUT_SCHEMA, CANDIDATE_WATCH_INPUT_VERSION, } from "../packages/contracts/candidate-watch-review.mjs";
+export function parseCandidateWatchInput(input) {
+    const value = typeof input === 'string'
+        ? parseBoundedJson(input, {
+            maximumBytes: MAX_WATCHLIST_IMPORT_BYTES,
+            label: 'Candidate watch selection',
+        })
+        : input;
+    const raw = ordinaryWorkspaceRecord(value, 'Candidate watch selection');
+    if (!raw ||
+        raw.schema !== CANDIDATE_WATCH_INPUT_SCHEMA ||
+        raw.version !== CANDIDATE_WATCH_INPUT_VERSION ||
+        Object.keys(raw).some((key) => !['schema', 'version', 'watchlists', 'selection'].includes(key)))
+        throw new TypeError('Use candidate-watch-input schema 1 with watchlists and an explicit selection.');
+    const selection = ordinaryWorkspaceRecord(raw.selection, 'Candidate watch selection');
+    if (!selection ||
+        Object.keys(selection).some((key) => ![
+            'name',
+            'candidates',
+            'brandProfileId',
+            'priority',
+            'reason',
+            'reviewDueAt',
+            'replaceExistingContext',
+        ].includes(key)))
+        throw new TypeError('The candidate selection contains undeclared fields.');
+    const local = raw.watchlists === null ? {} : mergeWatchlistStores({}, raw.watchlists).watchlists;
+    planCandidateWatchHandoff(local, selection);
+    return raw;
+}
+export function reviewCandidateWatchInput(input, operation, now) {
+    const raw = parseCandidateWatchInput(input), selection = raw.selection;
+    const local = raw.watchlists === null ? {} : mergeWatchlistStores({}, raw.watchlists).watchlists;
+    if (operation === 'plan')
+        return planCandidateWatchHandoff(local, selection);
+    const result = applyCandidateWatchHandoff(local, selection, now);
+    return buildWatchlistExport(result.watchlists, now);
+}