@slicedearth/whoisleuth-cli 2.3.0 → 2.4.0

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),