@slicedearth/whoisleuth-cli 2.3.0 → 2.5.1

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,154 +1,36 @@
 import { domainToASCII } from 'node:url';
 import { normalizeExplicitIsoTimestamp } from "../packages/evidence/observation.mjs";
-import { INVESTIGATION_PLAN_RECIPES, RUNNABLE_INVESTIGATION_PLAN_RECIPES, cliInvocationNetworkEffect, } from "./command-reference.mjs";
+import { cliInvocationNetworkEffect } from "./command-reference.mjs";
+import { INVESTIGATION_RECIPE_DEFINITIONS, INVESTIGATION_PLAN_RECIPES, RUNNABLE_INVESTIGATION_PLAN_RECIPES, } from "./investigation-recipes.mjs";
 export const CLI_INVESTIGATION_PLAN_SCHEMA = 'whoisleuth.cli.investigation-plan';
 export const CLI_INVESTIGATION_PLAN_VERSION = 1;
 export const CLI_WORKFLOW_RECIPE_CATALOGUE_SCHEMA = 'whoisleuth.cli.workflow-recipe-catalogue';
 export const CLI_WORKFLOW_RECIPE_CATALOGUE_VERSION = 1;
 export { INVESTIGATION_PLAN_RECIPES, RUNNABLE_INVESTIGATION_PLAN_RECIPES };
-const RECIPES = Object.freeze({
-    'domain-triage': Object.freeze({
-        id: 'domain-triage',
-        label: 'New domain triage',
-        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.',
-        ]),
-        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('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.'),
-        ]),
-    }),
-    'lookalike-review': Object.freeze({
-        id: 'lookalike-review',
-        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.',
-        ]),
-        steps: (subject) => Object.freeze([
-            step('generate', 'Generate candidates offline', 'discover', [subject, '--preset', 'all', '--json'], 'offline', 'none', 'whoisleuth.cli.discover', 'Review mutation families and suppressions before collection.'),
-            step('scan', 'Collect a bounded candidate queue', 'discover-scan', [subject, '--fast', '--scan-limit', '50', '--json'], 'network', 'network_disclosure', 'whoisleuth.cli.discovery-scan', 'Fast collection is a triage boundary; partial or inconclusive authority evidence remains explicit.'),
-            step('inspect', 'Deep-review one selected candidate', 'lookup', ['<selected-domain>', '--deep', '--json'], 'network', 'analyst_selection', 'whoisleuth.cli.lookup', 'Select a candidate deliberately; generation does not prove registration, control, intent, or maliciousness.'),
-        ]),
-    }),
-    'owned-domain-review': Object.freeze({
-        id: 'owned-domain-review',
-        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.'),
-        ]),
-    }),
-    'historical-comparison': Object.freeze({
-        id: 'historical-comparison',
-        label: 'Historical observation comparison',
-        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.'),
-            step('diff', 'Compare two selected observations', 'diff', ['<previous.json>', '<current.json>', '--json'], 'offline', 'analyst_selection', 'whoisleuth.cli.lookup-diff', 'Equal, different, conflicting, and unavailable evidence remain separate.'),
-            step('timeline', 'Build a bounded local timeline', 'timeline', ['<oldest.json>', '<newer.json>', '<current.json>', '--json'], 'offline', 'analyst_selection', 'whoisleuth.cli.lookup-timeline', 'Choose two to twenty same-domain files in chronological scope.'),
-        ]),
-    }),
-    'campaign-review': Object.freeze({
-        id: 'campaign-review',
-        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.'),
-        ]),
+const RECIPES = Object.freeze(Object.fromEntries(INVESTIGATION_PLAN_RECIPES.map((id) => [
+    id,
+    Object.freeze({
+        ...INVESTIGATION_RECIPE_DEFINITIONS[id],
+        id,
+        steps: (subject) => validatedSteps(INVESTIGATION_RECIPE_DEFINITIONS[id].steps(subject)),
     }),
-    'certificate-anomaly': Object.freeze({
-        id: 'certificate-anomaly',
-        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('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',
-        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.'),
-            step('compare', 'Compare registry publications offline', 'compare', ['<saved-lookup.json>', '--json'], 'offline', 'analyst_selection', 'whoisleuth.cli.compare', 'Do not convert conflicting or unavailable publications into equivalence.'),
-            step('report', 'Prepare a target-free source report', 'source-report', ['<saved-lookup.json>', '--json'], 'offline', 'analyst_selection', 'whoisleuth.source-reliability-report', 'The report describes source behaviour, not ownership, safety, or legal status.'),
-        ]),
-    }),
-    'evidence-handoff': Object.freeze({
-        id: 'evidence-handoff',
-        label: 'Reviewed evidence handoff',
-        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('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.'),
-        ]),
-    }),
-    'planned-domain-change': Object.freeze({
-        id: 'planned-domain-change',
-        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('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.'),
-        ]),
-    }),
-    'post-change-verification': Object.freeze({
-        id: 'post-change-verification',
-        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('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 +48,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),
@@ -202,15 +84,20 @@ export function formatWorkflowRecipeCatalogue(catalogue) {
         '',
     ].join('\n');
 }
-function step(id, label, command, args, mode, approval, produces, completion) {
-    const invocationEffect = cliInvocationNetworkEffect(command, args);
-    if ((mode === 'network') !== (invocationEffect === 'network')) {
-        throw new Error(`Investigation step ${id} does not match the registered network effect for ${command}.`);
+function validatedSteps(steps) {
+    for (const step of steps) {
+        const invocationEffect = cliInvocationNetworkEffect(step.command, step.arguments);
+        if ((step.mode === 'network') !== (invocationEffect === 'network')) {
+            throw new Error(`Investigation step ${step.id} does not match the registered network effect for ${step.command}.`);
+        }
     }
-    return Object.freeze({ id, label, command, arguments: Object.freeze([...args]), mode, approval, produces, completion });
+    return steps;
 }
 function boundedSubject(value) {
-    if (typeof value !== 'string' || !value.trim() || value.length > 253 || /[\u0000-\u001f\u007f]/u.test(value)) {
+    if (typeof value !== 'string' ||
+        !value.trim() ||
+        value.length > 253 ||
+        /[\u0000-\u001f\u007f]/u.test(value)) {
         throw new TypeError('Investigation-plan subject must be bounded text without control characters.');
     }
     return value.replace(/\s+/gu, ' ').trim();
@@ -219,7 +106,9 @@ function normalizedDomain(value) {
     const candidate = domainToASCII(value.toLowerCase().replace(/\.$/u, ''));
     if (!candidate || candidate.length > 253 || !candidate.includes('.'))
         return null;
-    return candidate.split('.').every((label) => /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/u.test(label))
+    return candidate
+        .split('.')
+        .every((label) => /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/u.test(label))
         ? candidate
         : null;
 }
@@ -228,7 +117,9 @@ export function buildInvestigationPlan(recipeId, subjectValue, generatedAtValue
     if (!recipe)
         throw new TypeError('Investigation-plan recipe is unsupported.');
     const suppliedSubject = boundedSubject(subjectValue);
-    const subject = recipe.subjectRequirement === 'domain' ? normalizedDomain(suppliedSubject) : suppliedSubject.toLowerCase();
+    const subject = recipe.subjectRequirement === 'domain'
+        ? normalizedDomain(suppliedSubject)
+        : suppliedSubject.toLowerCase();
     if (!subject)
         throw new TypeError('This investigation-plan recipe requires one valid domain.');
     const generatedAt = normalizeExplicitIsoTimestamp(generatedAtValue);