@slicedearth/whoisleuth-cli 2.2.0 → 2.4.0

package/cli/investigation-checkpoint.mjs

@@ -0,0 +1,10 @@
+import { MAX_INVESTIGATION_RUN_BYTES } from "../packages/contracts/investigation-run.mjs";
+import { prepareLocalDocumentWrite } from "./local-document-checkpoint.mjs";
+/** Preserve the workflow checkpoint interface and shared on-disk lease convention. */
+export async function prepareInvestigationCheckpoint(options) {
+    const checkpoint = await prepareLocalDocumentWrite({
+        ...options, source: options.resumeSource, label: 'Workflow state',
+        maximumInputBytes: MAX_INVESTIGATION_RUN_BYTES, maximumOutputBytes: MAX_INVESTIGATION_RUN_BYTES,
+    });
+    return Object.freeze({ resumeInput: checkpoint.sourceInput, publish: checkpoint.publish, release: checkpoint.release });
+}

package/cli/investigation-folder.mjs

@@ -0,0 +1,114 @@
+import { lstat, mkdir, opendir, realpath } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { readBoundedRegularFileWithin } from "../lib/bounded-file.mjs";
+import { writePrivateFile } from "./output-file.mjs";
+import { INVESTIGATION_PACKAGE_MANIFEST_PATH, MAX_INVESTIGATION_PACKAGE_ENTRIES, investigationPackagePath, prepareInvestigationPackageEntries, } from "../packages/investigation/investigation-package.mjs";
+import { MAX_INVESTIGATION_MANIFEST_ARTIFACT_BYTES, MAX_INVESTIGATION_MANIFEST_DOCUMENT_BYTES, MAX_INVESTIGATION_MANIFEST_TOTAL_BYTES, } from "../packages/investigation/investigation-manifest.mjs";
+export function selectedEvidenceDirectory(value) {
+    if (typeof value !== 'string' || !value || value === '-' || value.length > 4096 || /[\x00-\x1f\x7f]/u.test(value))
+        throw new TypeError('Select one bounded local folder path.');
+    return resolve(value);
+}
+export async function evidenceDirectoryIdentity(path) {
+    const value = await lstat(path);
+    if (!value.isDirectory() || value.isSymbolicLink())
+        throw new TypeError('Evidence folders must be ordinary directories, not symbolic links.');
+    return { device: value.dev, inode: value.ino, modified: value.mtimeMs, changed: value.ctimeMs };
+}
+/** Enumerate only the two declared levels; never walk an arbitrary source tree. */
+export async function readInvestigationFolder(value, signal) {
+    signal?.throwIfAborted();
+    const selected = selectedEvidenceDirectory(value);
+    const before = await evidenceDirectoryIdentity(selected), root = await realpath(selected);
+    const paths = [];
+    let nestedIdentity = null;
+    const directory = await opendir(root);
+    for await (const entry of directory) {
+        signal?.throwIfAborted();
+        if (entry.name === 'artifacts' && entry.isDirectory()) {
+            const nested = join(root, 'artifacts');
+            nestedIdentity = await evidenceDirectoryIdentity(nested);
+            for await (const file of await opendir(nested)) {
+                signal?.throwIfAborted();
+                if (!file.isFile())
+                    throw new TypeError('Evidence folder entries must be regular files.');
+                if (paths.length >= MAX_INVESTIGATION_PACKAGE_ENTRIES)
+                    throw new TypeError('Evidence folder has too many entries.');
+                paths.push(investigationPackagePath(`artifacts/${file.name}`));
+            }
+        }
+        else if (entry.name === INVESTIGATION_PACKAGE_MANIFEST_PATH && entry.isFile()) {
+            if (paths.length >= MAX_INVESTIGATION_PACKAGE_ENTRIES)
+                throw new TypeError('Evidence folder has too many entries.');
+            paths.push(entry.name);
+        }
+        else
+            throw new TypeError('Evidence folders contain only manifest.json and the declared artifacts directory.');
+    }
+    if (!nestedIdentity || !paths.includes(INVESTIGATION_PACKAGE_MANIFEST_PATH) || paths.length < 2)
+        throw new TypeError('Evidence folder is incomplete.');
+    const files = new Map();
+    let total = 0;
+    for (const name of paths.sort()) {
+        signal?.throwIfAborted();
+        const manifest = name === INVESTIGATION_PACKAGE_MANIFEST_PATH;
+        const maximumBytes = manifest ? MAX_INVESTIGATION_MANIFEST_DOCUMENT_BYTES : Math.min(MAX_INVESTIGATION_MANIFEST_ARTIFACT_BYTES, MAX_INVESTIGATION_MANIFEST_TOTAL_BYTES - total);
+        const bytes = await readBoundedRegularFileWithin(root, name, { maximumBytes, minimumBytes: 1, label: 'Evidence folder entry', ...(signal ? { signal } : {}) });
+        if (!manifest)
+            total += bytes.byteLength;
+        files.set(name, bytes);
+    }
+    const unchanged = (left, right) => left.device === right.device && left.inode === right.inode && left.modified === right.modified && left.changed === right.changed;
+    if (await realpath(selected) !== root || !unchanged(before, await evidenceDirectoryIdentity(selected))
+        || !unchanged(nestedIdentity, await evidenceDirectoryIdentity(join(root, 'artifacts'))))
+        throw new TypeError('Evidence folder changed while it was read.');
+    signal?.throwIfAborted();
+    return files;
+}
+/** Never replace an existing folder. The manifest is published only after files. */
+export async function writeInvestigationFolder(value, input, generatedAt, version, signal) {
+    const prepared = await prepareInvestigationPackageEntries(input, generatedAt, version);
+    await writePreparedEvidenceFolder(value, prepared.files, 'artifacts', INVESTIGATION_PACKAGE_MANIFEST_PATH, signal);
+    return prepared.manifest;
+}
+/** Only first-party, generated layouts may use this fresh-directory writer. */
+export async function writePreparedEvidenceFolder(value, files, payloadDirectory, completionFile, signal) {
+    const target = selectedEvidenceDirectory(value);
+    if (!files.has(completionFile) || !/^[a-z0-9.-]+$/u.test(completionFile)
+        || [...files.keys()].some(path => path !== `${payloadDirectory}/` && !/^[a-z0-9.-]+$/u.test(path) && !new RegExp(`^${payloadDirectory}/artifact-[1-9][0-9]{0,2}$`, 'u').test(path)))
+        throw new TypeError('The generated evidence folder layout is invalid.');
+    signal?.throwIfAborted();
+    try {
+        await mkdir(target, { mode: 0o700 });
+    }
+    catch {
+        throw new TypeError('The output folder must not already exist, and its parent must be writable. Existing files were not replaced.');
+    }
+    try {
+        const root = await realpath(target), identity = await evidenceDirectoryIdentity(target);
+        await mkdir(join(root, payloadDirectory), { mode: 0o700 });
+        const artifactsIdentity = await evidenceDirectoryIdentity(join(root, payloadDirectory));
+        const checkLocation = async () => {
+            signal?.throwIfAborted();
+            const current = await evidenceDirectoryIdentity(target), nested = await evidenceDirectoryIdentity(join(root, payloadDirectory));
+            if (await realpath(target) !== root || current.device !== identity.device || current.inode !== identity.inode
+                || nested.device !== artifactsIdentity.device || nested.inode !== artifactsIdentity.inode
+                || await realpath(join(root, payloadDirectory)) !== join(root, payloadDirectory))
+                throw new TypeError('Evidence output folder changed.');
+        };
+        for (const [name, content] of files) {
+            if (name === completionFile || name.endsWith('/'))
+                continue;
+            await checkLocation();
+            await writePrivateFile(join(root, name), content, { beforePublish: checkLocation });
+        }
+        await checkLocation();
+        await writePrivateFile(join(root, completionFile), files.get(completionFile), { beforePublish: checkLocation });
+        await checkLocation();
+    }
+    catch {
+        // Retain only this newly created partial output for deliberate inspection;
+        // recursive cleanup could remove unrelated files added by another process.
+        throw new TypeError('The new evidence folder could not be completed or confirmed. It may contain private partial output; inspect or remove it before choosing a new destination. Existing folders were not replaced.');
+    }
+}

package/cli/investigation-manifest.mjs

@@ -1,112 +1 @@
-import { Buffer } from 'node:buffer';
-import { createHash } from 'node:crypto';
-import { canonicalArtifactJsonV2, SORTED_JSON_V2, sha256ArtifactDigestV2, } from "../packages/evidence/artifact-integrity.mjs";
-import { requireBoundedString, requireIsoTimestamp, } from "../lib/bounded-contract-normalizers.mjs";
-import { normalizeBoundedSemanticVersion } from "../lib/semantic-version.mjs";
-import { parseBoundedJsonObject } from "./bounded-json.mjs";
-export const INVESTIGATION_MANIFEST_SCHEMA = 'whoisleuth.investigation-manifest';
-export const INVESTIGATION_MANIFEST_VERSION = 2;
-export const MAX_INVESTIGATION_MANIFEST_ARTIFACTS = 16;
-export const MAX_INVESTIGATION_MANIFEST_ARTIFACT_BYTES = 15 * 1024 * 1024;
-export const MAX_INVESTIGATION_MANIFEST_TOTAL_BYTES = 32 * 1024 * 1024;
-const SHA256_RE = /^sha256:[a-f0-9]{64}$/u;
-function digest(value) {
-    return `sha256:${createHash('sha256').update(value, 'utf8').digest('hex')}`;
-}
-function artifactVersion(value) {
-    const candidate = value.version ?? value.schemaVersion;
-    return Number.isSafeInteger(candidate) && Number(candidate) > 0 && Number(candidate) <= 1_000
-        ? Number(candidate)
-        : null;
-}
-export async function buildInvestigationManifest(input, generatedAtValue, applicationVersionValue) {
-    if (!Array.isArray(input.artifacts)
-        || input.artifacts.length < 1
-        || input.artifacts.length > MAX_INVESTIGATION_MANIFEST_ARTIFACTS) {
-        throw new TypeError(`A manifest requires between 1 and ${MAX_INVESTIGATION_MANIFEST_ARTIFACTS} JSON artefacts.`);
-    }
-    const generatedAt = requireIsoTimestamp(generatedAtValue, 'generatedAt');
-    const workflow = requireBoundedString(input.workflow, 'workflow', 160);
-    const applicationVersion = normalizeBoundedSemanticVersion(applicationVersionValue, 'Application');
-    const configurationDigestSha256 = input.configurationDigestSha256;
-    if (configurationDigestSha256 !== null && !SHA256_RE.test(configurationDigestSha256)) {
-        throw new TypeError('configurationDigestSha256 must be a sha256: hexadecimal digest.');
-    }
-    let totalBytes = 0;
-    const artifacts = input.artifacts.map((artifact, index) => {
-        if (typeof artifact.content !== 'string')
-            throw new TypeError(`Artifact ${index + 1} must be UTF-8 JSON text.`);
-        const byteLength = Buffer.byteLength(artifact.content, 'utf8');
-        totalBytes += byteLength;
-        if (byteLength < 1 || byteLength > MAX_INVESTIGATION_MANIFEST_ARTIFACT_BYTES) {
-            throw new TypeError(`Artifact ${index + 1} must be between 1 byte and ${MAX_INVESTIGATION_MANIFEST_ARTIFACT_BYTES} bytes.`);
-        }
-        if (totalBytes > MAX_INVESTIGATION_MANIFEST_TOTAL_BYTES) {
-            throw new TypeError(`Manifest artefacts exceed the ${MAX_INVESTIGATION_MANIFEST_TOTAL_BYTES}-byte combined limit.`);
-        }
-        const value = parseBoundedJsonObject(artifact.content, {
-            label: `Artifact ${index + 1}`,
-            maximumBytes: MAX_INVESTIGATION_MANIFEST_ARTIFACT_BYTES,
-        });
-        const schema = value.schema === undefined
-            ? null
-            : requireBoundedString(value.schema, `Artifact ${index + 1} schema`, 160);
-        const canonical = canonicalArtifactJsonV2(value);
-        const contentDigestSha256 = digest(artifact.content);
-        return Object.freeze({
-            sequence: index + 1,
-            id: `artifact-${index + 1}`,
-            schema,
-            version: artifactVersion(value),
-            byteLength,
-            contentDigestSha256,
-            canonicalDigestSha256: digest(canonical),
-        });
-    });
-    const unsigned = Object.freeze({
-        schema: INVESTIGATION_MANIFEST_SCHEMA,
-        version: INVESTIGATION_MANIFEST_VERSION,
-        generatedAt,
-        application: Object.freeze({ name: 'WHOISleuth CLI', version: applicationVersion }),
-        workflow,
-        configuration: Object.freeze({ digestSha256: configurationDigestSha256 }),
-        artifacts: Object.freeze(artifacts),
-        steps: Object.freeze(artifacts.map((artifact) => Object.freeze({
-            sequence: artifact.sequence,
-            artifactId: artifact.id,
-            contentDigestSha256: artifact.contentDigestSha256,
-        }))),
-        summary: Object.freeze({ artifactCount: artifacts.length, totalBytes }),
-        limitations: Object.freeze([
-            'The manifest records ordered content digests, schema metadata, tool version, and an optional configuration digest; it deliberately omits source file paths and content values.',
-            'Reproduction still depends on access to the exact input artefacts, compatible source services, and any separately retained configuration represented by the supplied digest.',
-            'Matching digests establish content identity, not the accuracy, provenance, or current validity of an observation.',
-        ]),
-    });
-    return Object.freeze({
-        ...unsigned,
-        integrity: Object.freeze({
-            algorithm: 'SHA-256',
-            canonicalization: SORTED_JSON_V2,
-            digestSha256: await sha256ArtifactDigestV2(unsigned),
-        }),
-    });
-}
-export function formatInvestigationManifest(manifest) {
-    const lines = [
-        'Investigation manifest',
-        `Workflow       ${manifest.workflow}`,
-        `Tool version   ${manifest.application.version}`,
-        `Artifacts      ${manifest.summary.artifactCount}`,
-        `Total bytes    ${manifest.summary.totalBytes}`,
-        `Configuration  ${manifest.configuration.digestSha256 ?? 'not supplied'}`,
-        `Integrity      ${manifest.integrity.digestSha256}`,
-        '',
-        'Ordered artefacts:',
-    ];
-    for (const artifact of manifest.artifacts) {
-        lines.push(`  ${artifact.sequence}. ${artifact.schema ?? 'unversioned JSON'}${artifact.version ? ` v${artifact.version}` : ''} · ${artifact.contentDigestSha256}`);
-    }
-    lines.push('', 'No source file paths or artefact contents are retained in this manifest.', '');
-    return lines.join('\n');
-}
+export * from "../packages/investigation/investigation-manifest.mjs";

package/cli/investigation-package-review.mjs

@@ -0,0 +1,103 @@
+import { sha256ArtifactBytes } from "../packages/evidence/artifact-integrity.mjs";
+import { MAX_INVESTIGATION_PACKAGE_BYTES, encodeInvestigationPackageEntries, inspectInvestigationPackage } from "../packages/investigation/investigation-package.mjs";
+import { INVESTIGATION_MANIFEST_SCHEMA } from "../packages/investigation/investigation-manifest.mjs";
+import { hasEncryptedInvestigationPackagePrefix, MAX_ENCRYPTED_INVESTIGATION_PACKAGE_BYTES } from "../packages/contracts/investigation-package-limits.mjs";
+import { decryptInvestigationPackage } from "../packages/investigation/investigation-package-crypto.mjs";
+import { readEditableCaseExport } from "../packages/cases/case-export-input.mjs";
+import { matchCaseReviewFiles } from "../packages/cases/case-review-package.mjs";
+import { OFFLINE_ARTIFACT_VERIFICATION_SCHEMA, OFFLINE_ARTIFACT_VERIFICATION_VERSION, UnsupportedOfflineArtifactError, isCompleteOfflineArtifactVerification, verifyOfflineArtifact, } from "./artifact-verify.mjs";
+export async function verifyOfflineInvestigationFolder(files) {
+    const report = await verifyOfflineInvestigationPackage(encodeInvestigationPackageEntries(files));
+    return Object.freeze({ ...report, limitations: Object.freeze([
+            'Folder input was converted in memory to the canonical stored-ZIP representation. Package digest and input byte count identify that representation, not filesystem metadata. No ZIP was written.',
+            ...report.limitations,
+        ]) });
+}
+export async function verifyOfflineInvestigationPackage(input, passphrase) {
+    if (!(input instanceof Uint8Array) || input.byteLength > MAX_ENCRYPTED_INVESTIGATION_PACKAGE_BYTES)
+        throw new TypeError('Investigation package exceeds its input limit.');
+    if (hasEncryptedInvestigationPackagePrefix(input)) {
+        if (typeof passphrase !== 'string')
+            throw new TypeError('Encrypted evidence packages require --passphrase-file. No content was decrypted.');
+        const decrypted = await decryptInvestigationPackage(input, passphrase);
+        try {
+            const report = await verifyOfflineInvestigationPackage(decrypted.bytes);
+            return Object.freeze({ ...report,
+                checks: Object.freeze({ ...report.checks, authenticatedEncryption: 'verified' }),
+                summary: Object.freeze({ ...report.summary, inputBytes: input.byteLength, ciphertextBytes: decrypted.ciphertextBytes }),
+                limitations: Object.freeze(['The complete encrypted container authenticated. Its package digest identifies the decrypted ZIP, not the encrypted file. Encryption does not establish source identity or factual accuracy.', ...report.limitations]),
+            });
+        }
+        finally {
+            decrypted.bytes.fill(0);
+        }
+    }
+    if (passphrase !== undefined)
+        throw new TypeError('A passphrase was supplied for an unencrypted evidence package. No encrypted-container assurance can be given.');
+    if (!(input instanceof Uint8Array) || input.byteLength > MAX_INVESTIGATION_PACKAGE_BYTES)
+        throw new TypeError('Investigation package exceeds its input limit.');
+    const bytes = new Uint8Array(input);
+    const inspected = await inspectInvestigationPackage(bytes);
+    const entries = [];
+    const caseFiles = [];
+    for (const reviewed of inspected.entries) {
+        let state = reviewed.state === 'rejected' ? 'rejected' : reviewed.interpretation === 'opaque' ? 'opaque' : 'unsupported';
+        let verification = null;
+        let issue = reviewed.issue ?? (reviewed.interpretation === 'unsupported_json_value'
+            ? 'JSON content identity is verified, but this value has no supported offline source-format reader.' : null);
+        if (reviewed.state === 'identity_verified' && reviewed.interpretation === 'not_checked') {
+            try {
+                const raw = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(inspected.contents.get(reviewed.entry.id));
+                const result = await verifyOfflineArtifact(raw);
+                verification = { artifact: result.artifact, state: result.state, checks: result.checks, summary: result.summary };
+                state = isCompleteOfflineArtifactVerification(result) ? 'admitted' : 'review_required';
+                if (state === 'review_required')
+                    issue = 'The supported reader requires additional verification before complete assurance.';
+                if (result.artifact.kind === 'case_export') {
+                    const candidates = inspected.entries.filter(item => item.entry.id !== reviewed.entry.id && item.state === 'identity_verified')
+                        .map(item => ({ id: item.entry.id, digestSha256: item.entry.contentDigestSha256, byteLength: item.entry.byteLength }));
+                    const cases = readEditableCaseExport(raw);
+                    let references = 0, missing = 0;
+                    for (const record of cases) {
+                        const matched = matchCaseReviewFiles(record, candidates);
+                        references += matched.length;
+                        missing += matched.filter(item => !item.entries.length).length;
+                    }
+                    // Keep incident identifiers and filenames out of redacted reports.
+                    caseFiles.push({ entryId: reviewed.entry.id, caseCount: cases.length, references, matched: references - missing, missing });
+                }
+            }
+            catch (cause) {
+                state = cause instanceof UnsupportedOfflineArtifactError ? 'unsupported' : 'rejected';
+                issue = state === 'unsupported' ? 'No supported offline reader accepts this declared source format.' : 'The source file failed its independent format or integrity checks.';
+            }
+        }
+        entries.push({ id: reviewed.entry.id, byteLength: reviewed.entry.byteLength,
+            mediaType: 'mediaType' in reviewed.entry ? reviewed.entry.mediaType : 'application/json',
+            state, identity: reviewed.state === 'identity_verified' ? 'verified' : 'failed', verification, issue });
+    }
+    const complete = entries.every((entry) => entry.state === 'admitted' || entry.state === 'opaque')
+        && inspected.links.every((link) => link.state === 'linked')
+        && inspected.captureManifests.every(capture => capture.state === 'matched')
+        && caseFiles.every(item => item.missing === 0);
+    return Object.freeze({
+        schema: OFFLINE_ARTIFACT_VERIFICATION_SCHEMA, version: OFFLINE_ARTIFACT_VERIFICATION_VERSION,
+        artifact: Object.freeze({ kind: 'investigation_package', schema: INVESTIGATION_MANIFEST_SCHEMA, version: inspected.manifest.version }),
+        state: complete ? 'verified' : 'partial',
+        checks: Object.freeze({ structure: 'verified', contentIntegrity: inspected.identityVerified ? 'verified' : 'failed',
+            contentIntegrityScope: 'manifest_and_files', authenticatedEncryption: 'not_applicable' }),
+        summary: Object.freeze({ inputBytes: bytes.byteLength, sectionCount: entries.length, recordCount: null, ciphertextBytes: null }),
+        manifestIdentity: null,
+        package: Object.freeze({ digestSha256: await sha256ArtifactBytes(bytes), audience: 'private', storageEffect: 'none',
+            signatureTrust: 'not_checked', timestampAssurance: 'not_checked', factualAccuracy: 'not_established',
+            entries: Object.freeze(entries), links: inspected.links, captureManifests: inspected.captureManifests, caseFiles: Object.freeze(caseFiles) }),
+        limitations: Object.freeze([
+            'The manifest and selected file bytes are checked independently. Re-compressing the ZIP can change its archive digest without changing its verified file content.',
+            'Opaque files are retained byte-for-byte, not rendered, executed or validated as images or documents. Unsupported JSON remains separate from admitted source formats.',
+            '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.',
+            '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/investigation-plan.mjs

@@ -1,5 +1,9 @@
 import { domainToASCII } from 'node:url';
 import { normalizeExplicitIsoTimestamp } from "../packages/evidence/observation.mjs";
+import { CLI_DOMAIN_CONTROL_MONITOR_SCHEMA } from "../packages/contracts/domain-control-monitor.mjs";
+import { DOMAIN_CONTROL_REVIEW_SCHEMA } from "../packages/contracts/domain-control-review.mjs";
+import { EXTERNAL_FINDINGS_SCHEMA } from "../packages/interchange/external-findings-import.mjs";
+import { CLI_LOOKUP_BRIEF_SCHEMA } from "./lookup-brief.mjs";
 import { INVESTIGATION_PLAN_RECIPES, RUNNABLE_INVESTIGATION_PLAN_RECIPES, cliInvocationNetworkEffect, } from "./command-reference.mjs";
 export const CLI_INVESTIGATION_PLAN_SCHEMA = 'whoisleuth.cli.investigation-plan';
 export const CLI_INVESTIGATION_PLAN_VERSION = 1;
@@ -10,16 +14,19 @@ const RECIPES = Object.freeze({
     'domain-triage': Object.freeze({
         id: 'domain-triage',
         label: 'New domain triage',
+        standardInputs: Object.freeze([
+            { stepId: 'export', input: 1, sourceStepId: 'collect' },
+            { stepId: 'verify', input: 1, sourceStepId: 'export' },
+        ]),
         subjectRequirement: 'domain',
         objective: 'Collect and preserve separately attributed registration, DNS, HTTP, TLS, page, and network-context evidence.',
-        runnable: true,
         limitations: Object.freeze([
             'Collection remains analyst-triggered and source limitations remain explicit.',
-            'Disposition, reviewed response actions, monitoring, and closure continue in the browser-local Case workspace; this CLI recipe does not submit reports.',
+            'Disposition, reviewed response actions, monitoring, and closure continue in the saved Case workspace; this CLI recipe does not submit reports.',
         ]),
         steps: (domain) => Object.freeze([
             step('collect', 'Collect a Deep lookup', 'lookup', [domain, '--deep', '--json'], 'network', 'network_disclosure', 'whoisleuth.cli.lookup', 'Review source health and limitations before using missing fields.'),
-            step('export', 'Create a portable evidence report', 'export', ['<saved-lookup.json>'], 'offline', 'analyst_selection', 'whoisleuth.lookup-evidence', 'Select the reviewed lookup file; the plan never guesses a path.'),
+            step('export', 'Create a portable evidence report', 'export', ['<saved-lookup.json>'], 'offline', 'analyst_selection', 'whoisleuth.lookup-evidence', 'Reuse the collected Lookup by default, or select a different reviewed Lookup file.'),
             step('verify', 'Verify the exported artefact', 'verify-artifact', ['<evidence.json>', '--json'], 'offline', 'analyst_selection', 'whoisleuth.offline-artifact-verification', 'Keep verification distinct from a claim that the observations are correct or current.'),
         ]),
     }),
@@ -28,7 +35,6 @@ const RECIPES = Object.freeze({
         label: 'Lookalike candidate review',
         subjectRequirement: 'brand_or_domain',
         objective: 'Generate a bounded candidate queue, collect only the selected scope, and retain a reviewed candidate lookup.',
-        runnable: true,
         limitations: Object.freeze([
             'Candidate generation does not establish registration, control, intent, or maliciousness.',
             'Official-reference collection and page comparison require analyst-selected saved evidence; use page-compare after retaining the reference and candidate observations.',
@@ -44,20 +50,22 @@ const RECIPES = Object.freeze({
         label: 'Owned domain posture review',
         subjectRequirement: 'domain',
         objective: 'Review current passive posture and compare supplied observations with an analyst-authored control manifest.',
-        runnable: true,
         limitations: Object.freeze(['Use only for a domain the analyst owns or is authorised to review.']),
         steps: (domain) => Object.freeze([
             step('posture', 'Collect bounded DNS posture', 'posture', [domain, '--json'], 'network', 'network_disclosure', 'whoisleuth.cli.posture', 'Review mail profile and delegation evidence before interpreting missing records.'),
             step('lookup', 'Collect supporting Deep evidence', 'lookup', [domain, '--deep', '--json'], 'network', 'network_disclosure', 'whoisleuth.cli.lookup', 'Retain separately attributed registration, DNS, TLS, and page observations.'),
-            step('manifest', 'Review the domain control manifest', 'domain-control', ['<review-input.json>', '--json'], 'offline', 'analyst_selection', 'whoisleuth.domain-control-review', 'Only complete supplied observations may produce drift.'),
+            step('manifest', 'Review the domain control manifest', 'domain-control', ['<review-input.json>', '--json'], 'offline', 'analyst_selection', DOMAIN_CONTROL_REVIEW_SCHEMA, 'Only complete supplied observations may produce drift.'),
         ]),
     }),
     'historical-comparison': Object.freeze({
         id: 'historical-comparison',
         label: 'Historical observation comparison',
+        standardInputs: Object.freeze([
+            { stepId: 'diff', input: 2, sourceStepId: 'current' },
+            { stepId: 'timeline', input: 3, sourceStepId: 'current' },
+        ]),
         subjectRequirement: 'domain',
         objective: 'Collect a current observation and compare it with analyst-selected saved observations without merging source states.',
-        runnable: true,
         limitations: Object.freeze(['A later observation does not retroactively refresh retained evidence.']),
         steps: (domain) => Object.freeze([
             step('current', 'Collect the current lookup', 'lookup', [domain, '--deep', '--json'], 'network', 'network_disclosure', 'whoisleuth.cli.lookup', 'A current request does not refresh or validate older provider-reported history.'),
@@ -70,12 +78,11 @@ const RECIPES = Object.freeze({
         label: 'Campaign candidate review',
         subjectRequirement: 'brand_or_domain',
         objective: 'Prepare a bounded candidate set, collect a deliberately selected queue, and review retained evidence without asserting campaign attribution.',
-        runnable: false,
         limitations: Object.freeze(['Grouping candidates is analyst triage and does not prove common ownership, control, infrastructure, or intent.']),
         steps: (subject) => Object.freeze([
             step('prepare', 'Prepare candidates offline', 'discover', [subject, '--preset', 'all', '--json'], 'offline', 'none', 'whoisleuth.cli.discover', 'Review mutation families and bounded omissions before selecting a collection scope.'),
             step('collect', 'Collect the selected candidate queue', 'discover-scan', [subject, '--fast', '--scan-limit', '50', '--json'], 'network', 'network_disclosure', 'whoisleuth.cli.discovery-scan', 'Treat partial and inconclusive authority results as explicit outcomes.'),
-            step('review', 'Review selected retained evidence', 'review-evidence', ['<selected-evidence.json>', '--json'], 'offline', 'analyst_selection', 'whoisleuth.cli.offline-evidence-review', 'Keep source observations separate and record any campaign grouping as analyst-authored.'),
+            step('review', 'Prepare a selected candidate brief', 'brief', ['<saved-lookup.json>', '--json'], 'offline', 'analyst_selection', CLI_LOOKUP_BRIEF_SCHEMA, 'Select a saved candidate Lookup; keep any campaign grouping analyst-authored.'),
         ]),
     }),
     'certificate-anomaly': Object.freeze({
@@ -83,20 +90,22 @@ const RECIPES = Object.freeze({
         label: 'Certificate anomaly review',
         subjectRequirement: 'domain',
         objective: 'Review bounded certificate observations alongside current source-qualified domain evidence without treating issuance as proof of control or intent.',
-        runnable: false,
         limitations: Object.freeze(['Certificate observations are separately attributed and do not establish current service control.']),
         steps: (domain) => Object.freeze([
             step('search', 'Collect bounded certificate observations', 'ct-search', [domain, '--json'], 'network', 'network_disclosure', 'whoisleuth.cli.ct-search', 'Review source availability, truncation, and observation timing.'),
-            step('intake', 'Normalise the selected observations', 'ct-intake', ['<certificate-events.json>', '--json'], 'offline', 'analyst_selection', 'whoisleuth.ct-event-batch', 'Only selected saved observations enter the offline intake.'),
+            step('intake', 'Normalise the selected observations', 'ct-intake', ['<certificate-events.json>', '--json'], 'offline', 'analyst_selection', EXTERNAL_FINDINGS_SCHEMA, 'Select a certificate-event batch; a certificate-search report is not interchangeable with that input.'),
             step('corroborate', 'Collect supporting domain evidence', 'lookup', [domain, '--deep', '--json'], 'network', 'network_disclosure', 'whoisleuth.cli.lookup', 'Compare evidence families without collapsing certificate and registration identities.'),
         ]),
     }),
     'registry-disagreement': Object.freeze({
         id: 'registry-disagreement',
         label: 'Registry disagreement review',
+        standardInputs: Object.freeze([
+            { stepId: 'compare', input: 1, sourceStepId: 'collect' },
+            { stepId: 'report', input: 1, sourceStepId: 'collect' },
+        ]),
         subjectRequirement: 'domain',
         objective: 'Collect separately attributed registration evidence and review conflicting publications without selecting an arbitrary source as truth.',
-        runnable: false,
         limitations: Object.freeze(['Only authority-aware registration evidence may decide availability; disagreement remains explicit.']),
         steps: (domain) => Object.freeze([
             step('collect', 'Collect source-qualified registration evidence', 'lookup', [domain, '--deep', '--json'], 'network', 'network_disclosure', 'whoisleuth.cli.lookup', 'Retain RDAP, registrar RDAP, WHOIS, and authority states separately.'),
@@ -107,12 +116,12 @@ const RECIPES = Object.freeze({
     'evidence-handoff': Object.freeze({
         id: 'evidence-handoff',
         label: 'Reviewed evidence handoff',
+        standardInputs: Object.freeze([{ stepId: 'lint', input: 1, sourceStepId: 'package' }]),
         subjectRequirement: 'review_label',
         objective: 'Verify, minimise, and package analyst-selected evidence for a deliberate handoff without transmitting or submitting it.',
-        runnable: false,
         limitations: Object.freeze(['The recipe prepares local material only; sharing remains a separate deliberate action.']),
         steps: () => Object.freeze([
-            step('verify', 'Verify the selected artefact', 'verify-artifact', ['<evidence.json>', '--json'], 'offline', 'analyst_selection', 'whoisleuth.offline-artifact-verification', 'Verification checks structure and integrity, not the truth or currency of observations.'),
+            step('verify', 'Verify the selected artefact', 'verify-artifact', ['<evidence.json>', '--json', '--strict-exit'], 'offline', 'analyst_selection', 'whoisleuth.offline-artifact-verification', 'Verification checks structure and integrity, not the truth or currency of observations.'),
             step('package', 'Build a reviewed public Case-pack', 'case-pack', ['<cases.json>', '--audience', 'public', '--reviewed', '--json'], 'offline', 'analyst_selection', 'whoisleuth.cli.case-pack', 'Review minimisation and audience projection before retaining the separate package.'),
             step('lint', 'Review deliberate-sharing metadata', 'sharing-review', ['<package.json>', '--marking', 'clear', '--recipient-scope', 'public', '--purpose', 'reviewed evidence handoff', '--human-reviewed', '--personal-data-reviewed', '--redactions-confirmed', '--json'], 'offline', 'analyst_selection', 'whoisleuth.cli.sharing-review', 'A clear lint result does not send, upload, publish, or authorise the artefact.'),
         ]),
@@ -122,10 +131,9 @@ const RECIPES = Object.freeze({
         label: 'Planned domain change',
         subjectRequirement: 'domain',
         objective: 'Review an analyst-authored desired state and prepare bounded change material without changing DNS, registry, mail, or hosted configuration.',
-        runnable: false,
         limitations: Object.freeze(['Planning and packaging never apply, submit, schedule, or enforce a change.']),
         steps: () => Object.freeze([
-            step('control', 'Review the desired-state manifest', 'domain-control', ['<review-input.json>', '--json'], 'offline', 'analyst_selection', 'whoisleuth.domain-control-review', 'Only supplied complete observations may produce drift.'),
+            step('control', 'Review the desired-state manifest', 'domain-control', ['<review-input.json>', '--json'], 'offline', 'analyst_selection', DOMAIN_CONTROL_REVIEW_SCHEMA, 'Only supplied complete observations may produce drift.'),
             step('assure', 'Review change and recovery assumptions', 'assurance', ['<assurance-input.json>', '--json'], 'offline', 'analyst_selection', 'whoisleuth.domain-assurance', 'Record uncertainty, rollback dependencies, and unavailable evidence explicitly.'),
             step('package', 'Build a reviewed change packet', 'change-packet', ['<change-packet-input.json>', '--json'], 'offline', 'analyst_selection', 'whoisleuth.domain-change-packet', 'The packet is local reviewed material and performs no submission or enforcement.'),
         ]),
@@ -135,20 +143,25 @@ const RECIPES = Object.freeze({
         label: 'Post-change verification',
         subjectRequirement: 'domain',
         objective: 'Perform one explicit later observation and compare it with analyst-selected retained evidence after an authorised change.',
-        runnable: false,
         limitations: Object.freeze(['This is a one-time recheck, not monitoring setup or proof that every resolver or service has converged.']),
         steps: () => Object.freeze([
-            step('recheck', 'Run one bounded retained-manifest review', 'monitor-once', ['<manifest.json>', '--limit', '1', '--json'], 'network', 'network_disclosure', 'whoisleuth.domain-control-review', 'One later observation may remain partial, unavailable, stale, or conflicting.'),
+            step('recheck', 'Run one bounded retained-manifest review', 'monitor-once', ['<manifest.json>', '--limit', '1', '--json'], 'network', 'network_disclosure', CLI_DOMAIN_CONTROL_MONITOR_SCHEMA, 'One later observation may remain partial, unavailable, stale, or conflicting.'),
             step('compare', 'Compare selected before and after evidence', 'diff', ['<before.json>', '<after.json>', '--json'], 'offline', 'analyst_selection', 'whoisleuth.cli.lookup-diff', 'Materiality is derived from compatible retained evidence and does not infer intent.'),
             step('record', 'Record reviewed completion material', 'change-packet', ['<post-change-input.json>', '--json'], 'offline', 'analyst_selection', 'whoisleuth.domain-change-packet', 'Recording reviewed material does not submit it or start automatic monitoring.'),
         ]),
     }),
 });
 export const INVESTIGATION_RECIPE_REGISTRY = RECIPES;
+export function workflowStandardInputs(recipe) {
+    return RECIPES[recipe].standardInputs ?? [];
+}
 export const INVESTIGATION_PLAN_RECIPE_LABELS = Object.freeze(Object.fromEntries(INVESTIGATION_PLAN_RECIPES.map((recipe) => [recipe, RECIPES[recipe].label])));
 export function isRunnableInvestigationRecipe(value) {
     return RUNNABLE_INVESTIGATION_PLAN_RECIPES.includes(value);
 }
+export function workflowReviewDeclarations(step) {
+    return step.arguments.filter(argument => ['--reviewed', '--human-reviewed', '--personal-data-reviewed', '--redactions-confirmed'].includes(argument));
+}
 function recipeCatalogueEntry(recipe) {
     const exampleSubject = recipe.subjectRequirement === 'domain' ? 'example.test' : 'Example Organisation';
     const steps = recipe.steps(exampleSubject).map((item) => Object.freeze({
@@ -166,7 +179,7 @@ function recipeCatalogueEntry(recipe) {
         label: recipe.label,
         objective: recipe.objective,
         subjectRequirement: recipe.subjectRequirement,
-        runnableByWorkflowRun: recipe.runnable,
+        runnableByWorkflowRun: isRunnableInvestigationRecipe(recipe.id),
         networkModes: Object.freeze([...new Set(steps.map((item) => item.mode))]),
         approvals: Object.freeze([...new Set(steps.map((item) => item.approval))]),
         steps: Object.freeze(steps),