@slicedearth/whoisleuth-cli 2.3.0 → 2.5.1

package/cli/artifact-verify.mjs

@@ -1,24 +1,26 @@
 import { Buffer } from 'node:buffer';
+import { MANAGED_INDICATOR_SET_SCHEMA, MANAGED_INDICATOR_SET_VERSION } from "../packages/contracts/analyst-interchange.mjs";
 import { createHash } from 'node:crypto';
-import { parseBoundedJsonObject } from "./bounded-json.mjs";
+import { readEditableCaseExport } from "../packages/cases/case-export-input.mjs";
+import { boundedJsonLimitsForBytes, parseBoundedJsonObject } from "./bounded-json.mjs";
 import { validateInvestigationCapsuleStructure, validateLookupEvidenceArtifactStructure, validateOfflineArtifactStructure, validateSignedDigestArtifactStructure, } from "./offline-artifact-validation.mjs";
 import { verifyCaseResponsePacketIntegrity, } from "../packages/cases/case-response-packet.mjs";
 import { CASE_PORTABILITY_VERIFIER_DISPATCH, CASE_RESPONSE_PACKET_VERSION, CASE_RESPONSE_PACKET_SCHEMA, CLI_CASE_PACK_VERSION, CLI_CASE_PACK_SCHEMA, } from "../packages/contracts/case-portability.mjs";
 import { ACQUISITION_DECISION_PACKET_SCHEMA, BULK_DOMAIN_COMPARISON_SCHEMA, BULK_MAIL_EXPOSURE_SCHEMA, BULK_REVIEW_MANIFEST_SCHEMA, LOOKUP_CLAIM_PASSPORT_SCHEMA, LOOKUP_CLAIM_PASSPORT_VERSION, SUPPORTED_ACQUISITION_DECISION_PACKET_VERSIONS, SUPPORTED_BULK_DOMAIN_COMPARISON_EXPORT_VERSIONS, SUPPORTED_BULK_MAIL_EXPOSURE_EXPORT_VERSIONS, SUPPORTED_BULK_REVIEW_MANIFEST_VERSIONS, } from "../packages/contracts/investigation-portability.mjs";
-import { decryptWorkspaceArchive, inspectEncryptedWorkspaceArchive, isEncryptedWorkspaceArchive, } from "../packages/workspace/workspace-archive-crypto.mjs";
-import { WORKSPACE_ARCHIVE_SCHEMA, previewWorkspaceArchive, readWorkspaceArchive, } from "../packages/workspace/workspace-archive.mjs";
+import { decryptWorkspaceArchiveWithMetadata, inspectEncryptedWorkspaceArchive, isEncryptedWorkspaceArchive, MAX_ENCRYPTED_WORKSPACE_ARCHIVE_BYTES, } from "../packages/workspace/workspace-archive-crypto.mjs";
+import { WORKSPACE_ARCHIVE_SCHEMA, prepareWorkspaceArchive, readWorkspaceArchive, } from "../packages/workspace/workspace-archive.mjs";
 import { canonicalArtifactJsonFor, resolveArtifactCanonicalization, sha256ArtifactDigestFor, SORTED_JSON_V2, } from "../packages/evidence/artifact-integrity.mjs";
 import { SAVED_LOOKUP_SCHEMA, SUPPORTED_SAVED_LOOKUP_SCHEMA_VERSIONS, parseCliLookupDocument, } from "./saved-lookup.mjs";
 import { DOMAIN_CONTROL_MANIFEST_SCHEMA, verifyDomainControlManifest, } from "../lib/domain-control-manifest.mjs";
-import { DOMAIN_CONTROL_MANIFEST_CANONICALIZATION_ROUTES, } from "../packages/contracts/domain-control-manifest.mjs";
-import { DOMAIN_CHANGE_PACKET_SCHEMA, DOMAIN_CHANGE_PACKET_VERSION, } from "../lib/domain-change-packet.mjs";
+import { DOMAIN_CONTROL_MANIFEST_CANONICALIZATION_ROUTES, MAX_DOMAIN_CONTROL_MANIFEST_BYTES, } from "../packages/contracts/domain-control-manifest.mjs";
+import { DOMAIN_CHANGE_PACKET_SCHEMA, SUPPORTED_DOMAIN_CHANGE_PACKET_VERSIONS, } from "../lib/domain-change-packet.mjs";
 import { INVESTIGATION_CAPSULE_SCHEMA, SUPPORTED_INVESTIGATION_CAPSULE_VERSIONS, verifyInvestigationCapsule, } from "../packages/investigation/investigation-capsule.mjs";
-import { INVESTIGATION_MANIFEST_SCHEMA, INVESTIGATION_MANIFEST_VERSION, } from "./investigation-manifest.mjs";
+import { INVESTIGATION_MANIFEST_SCHEMA, SUPPORTED_INVESTIGATION_MANIFEST_VERSIONS, } from "./investigation-manifest.mjs";
 import { verifyCliCasePack } from "./case-pack.mjs";
 import { LOOKUP_EVIDENCE_PORTABLE_MAX_BYTES, LOOKUP_EVIDENCE_SCHEMA, SUPPORTED_LOOKUP_EVIDENCE_SCHEMA_VERSIONS, } from "../lib/evidence-export.mjs";
 export const OFFLINE_ARTIFACT_VERIFICATION_SCHEMA = 'whoisleuth.offline-artifact-verification';
-export const OFFLINE_ARTIFACT_VERIFICATION_VERSION = 3;
-export const MAX_OFFLINE_ARTIFACT_BYTES = 15 * 1024 * 1024;
+export const OFFLINE_ARTIFACT_VERIFICATION_VERSION = 4;
+export const MAX_OFFLINE_ARTIFACT_BYTES = Math.max(MAX_DOMAIN_CONTROL_MANIFEST_BYTES, MAX_ENCRYPTED_WORKSPACE_ARCHIVE_BYTES);
 export const MAX_OFFLINE_PASSPHRASE_FILE_BYTES = 1024;
 export class UnsupportedOfflineArtifactError extends TypeError {
     code = 'unsupported_artifact';
@@ -35,14 +37,15 @@ function currentCanonicalizationRoutes(versions) {
     })));
 }
 const SIGNED_ARTIFACT_ROUTES = Object.freeze({
+    [MANAGED_INDICATOR_SET_SCHEMA]: currentCanonicalizationRoutes([MANAGED_INDICATOR_SET_VERSION]),
     [ACQUISITION_DECISION_PACKET_SCHEMA]: currentCanonicalizationRoutes(SUPPORTED_ACQUISITION_DECISION_PACKET_VERSIONS),
     [LOOKUP_CLAIM_PASSPORT_SCHEMA]: currentCanonicalizationRoutes([LOOKUP_CLAIM_PASSPORT_VERSION]),
     [BULK_DOMAIN_COMPARISON_SCHEMA]: currentCanonicalizationRoutes(SUPPORTED_BULK_DOMAIN_COMPARISON_EXPORT_VERSIONS),
     [BULK_MAIL_EXPOSURE_SCHEMA]: currentCanonicalizationRoutes(SUPPORTED_BULK_MAIL_EXPOSURE_EXPORT_VERSIONS),
     [BULK_REVIEW_MANIFEST_SCHEMA]: currentCanonicalizationRoutes(SUPPORTED_BULK_REVIEW_MANIFEST_VERSIONS),
     [DOMAIN_CONTROL_MANIFEST_SCHEMA]: DOMAIN_CONTROL_MANIFEST_CANONICALIZATION_ROUTES,
-    [DOMAIN_CHANGE_PACKET_SCHEMA]: currentCanonicalizationRoutes([DOMAIN_CHANGE_PACKET_VERSION]),
-    [INVESTIGATION_MANIFEST_SCHEMA]: currentCanonicalizationRoutes([INVESTIGATION_MANIFEST_VERSION]),
+    [DOMAIN_CHANGE_PACKET_SCHEMA]: currentCanonicalizationRoutes(SUPPORTED_DOMAIN_CHANGE_PACKET_VERSIONS),
+    [INVESTIGATION_MANIFEST_SCHEMA]: currentCanonicalizationRoutes(SUPPORTED_INVESTIGATION_MANIFEST_VERSIONS),
 });
 function record(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
@@ -83,8 +86,16 @@ function rejectUnsupportedCasePortabilityVersion(label, version, currentVersion)
     }
     throw new UnsupportedOfflineArtifactError(`This ${label} version is malformed or unsupported; no data was changed.`);
 }
-function parseJson(raw) {
-    return parseBoundedJsonObject(raw, { maximumBytes: MAX_OFFLINE_ARTIFACT_BYTES });
+export function parseOfflineArtifactJson(raw) {
+    const value = parseBoundedJsonObject(raw, {
+        maximumBytes: MAX_OFFLINE_ARTIFACT_BYTES,
+        limits: boundedJsonLimitsForBytes(MAX_OFFLINE_ARTIFACT_BYTES),
+    });
+    if (value.schema !== WORKSPACE_ARCHIVE_SCHEMA && !isEncryptedWorkspaceArchive(value)
+        && Buffer.byteLength(raw, 'utf8') > MAX_DOMAIN_CONTROL_MANIFEST_BYTES) {
+        throw new TypeError(`Non-workspace artefacts are limited to ${MAX_DOMAIN_CONTROL_MANIFEST_BYTES} bytes.`);
+    }
+    return value;
 }
 export function hasVerifiedArtifactStructure(report) {
     return report.checks.structure === 'verified';
@@ -92,6 +103,7 @@ export function hasVerifiedArtifactStructure(report) {
 export function hasVerifiedApplicableIntegrity(report) {
     return report.checks.contentIntegrity === 'verified'
         && (report.checks.contentIntegrityScope === 'whole_artifact'
+            || report.checks.contentIntegrityScope === 'manifest_and_files'
             || report.checks.contentIntegrityScope === 'embedded_projections');
 }
 export function hasVerifiedWholeArtifactIntegrity(report) {
@@ -108,6 +120,9 @@ export function offlineArtifactSatisfiesAssurance(report, requirement) {
     return hasVerifiedWholeArtifactIntegrity(report);
 }
 export function isCompleteOfflineArtifactVerification(report) {
+    if (report.artifact.kind === 'bagit')
+        return report.state === 'integrity_valid' && report.bagit?.state === 'valid'
+            && report.checks.structure === 'verified' && report.checks.contentIntegrity === 'verified';
     return (report.state === 'verified' || report.state === 'structure_valid')
         && (report.manifestIdentity === null || report.manifestIdentity.state === 'identity_verified');
 }
@@ -124,8 +139,7 @@ function artifactVersion(value) {
 function inputBytes(raw) {
     return Buffer.byteLength(raw, 'utf8');
 }
-async function archiveReport(raw, source, archive, encrypted, ciphertextBytes) {
-    const preview = await previewWorkspaceArchive(source, {});
+function archiveReport(raw, archive, preview, encrypted, ciphertextBytes) {
     const readySectionCount = preview.sections.filter((section) => section.status === 'ready').length;
     const unsupportedSectionCount = preview.sections.filter((section) => section.status === 'unsupported').length;
     const blockedSectionCount = preview.sections.filter((section) => section.status === 'blocked').length;
@@ -172,6 +186,24 @@ async function archiveReport(raw, source, archive, encrypted, ciphertextBytes) {
         ]),
     });
 }
+async function verifyWorkspaceArchiveValue(raw, value, passphrase) {
+    const encrypted = isEncryptedWorkspaceArchive(value);
+    if (encrypted && !passphrase) {
+        throw new TypeError('Encrypted archive inspection requires a separate passphrase file.');
+    }
+    if (!encrypted)
+        artifactVersion(value);
+    const decrypted = encrypted ? await decryptWorkspaceArchiveWithMetadata(value, passphrase) : null;
+    const source = decrypted ? decrypted.archive : value;
+    const prepared = await prepareWorkspaceArchive(source);
+    const archive = prepared.read();
+    const report = archiveReport(raw, archive, prepared.preview({}), encrypted, decrypted?.ciphertextBytes ?? null);
+    return { archive, report, encrypted };
+}
+/** Verify an archive once and retain its sections for bounded offline inspection. */
+export async function verifyOfflineWorkspaceArchive(raw, options = {}) {
+    return verifyWorkspaceArchiveValue(raw, parseOfflineArtifactJson(raw), options.passphrase);
+}
 async function verifySignedArtifact(raw, value, schema, version) {
     const routes = SIGNED_ARTIFACT_ROUTES[schema] ?? [];
     if (!routes.some((route) => route.version === version)) {
@@ -215,7 +247,7 @@ async function verifySignedArtifact(raw, value, schema, version) {
     });
 }
 async function verifyOfflineArtifactCore(raw, options = {}) {
-    const value = parseJson(raw);
+    const value = parseOfflineArtifactJson(raw);
     const casePortabilityVerifier = selectCasePortabilityVerifier(value);
     if (casePortabilityVerifier?.id === 'cli-case-pack') {
         const casePackVersion = casePortabilityVersion(casePortabilityVerifier, value);
@@ -249,9 +281,24 @@ async function verifyOfflineArtifactCore(raw, options = {}) {
             ]),
         });
     }
+    if (value.schema === undefined && Array.isArray(value.cases)) {
+        const cases = readEditableCaseExport(raw);
+        return Object.freeze({
+            schema: OFFLINE_ARTIFACT_VERIFICATION_SCHEMA, version: OFFLINE_ARTIFACT_VERIFICATION_VERSION,
+            artifact: Object.freeze({ kind: 'case_export', schema: null, version: artifactVersion(value) }),
+            state: 'structure_valid',
+            checks: Object.freeze({ structure: 'verified', contentIntegrity: 'not_checked', contentIntegrityScope: 'not_applicable', authenticatedEncryption: 'not_applicable' }),
+            summary: Object.freeze({ inputBytes: inputBytes(raw), sectionCount: 1, recordCount: cases.length, ciphertextBytes: null }),
+            limitations: Object.freeze([
+                'The ordinary Case export matches its exact supported structure without repairing or removing retained records. It has no embedded checksum or signature.',
+                'Original-file references do not include original bytes. Verify a selected evidence package to check which references have matching bytes.',
+                'The Case includes private analyst content. Structural validity does not authenticate its author or establish factual accuracy, currentness or response authority.',
+            ]),
+        });
+    }
     if (isEncryptedWorkspaceArchive(value)) {
-        const inspected = inspectEncryptedWorkspaceArchive(value);
         if (!options.passphrase) {
+            const inspected = inspectEncryptedWorkspaceArchive(value);
             return Object.freeze({
                 schema: OFFLINE_ARTIFACT_VERIFICATION_SCHEMA,
                 version: OFFLINE_ARTIFACT_VERIFICATION_VERSION,
@@ -279,14 +326,12 @@ async function verifyOfflineArtifactCore(raw, options = {}) {
                 ]),
             });
         }
-        const decrypted = await decryptWorkspaceArchive(value, options.passphrase);
-        const archive = await readWorkspaceArchive(decrypted);
-        return archiveReport(raw, decrypted, archive, true, inspected.ciphertextBytes);
+        return (await verifyWorkspaceArchiveValue(raw, value, options.passphrase)).report;
     }
     const schema = typeof value.schema === 'string' ? value.schema : '';
     const version = artifactVersion(value);
     if (schema === WORKSPACE_ARCHIVE_SCHEMA) {
-        return archiveReport(raw, value, await readWorkspaceArchive(value), false, null);
+        return (await verifyWorkspaceArchiveValue(raw, value)).report;
     }
     if (casePortabilityVerifier?.id === 'case-response-packet') {
         if (!supportsCasePortabilityVersion(casePortabilityVerifier, version)) {
@@ -432,13 +477,13 @@ async function verifyManifestIdentity(artifactRaw, manifestRaw, entryId) {
         || manifestReport.checks.contentIntegrityScope !== 'whole_artifact') {
         throw new TypeError('The selected manifest is not a fully integrity-verified investigation manifest.');
     }
-    const manifest = parseJson(manifestRaw);
+    const manifest = parseOfflineArtifactJson(manifestRaw);
     const entries = Array.isArray(manifest.artifacts) ? manifest.artifacts : [];
     const entry = entries.find((candidate) => record(candidate)?.id === entryId);
     const item = record(entry);
     if (!item)
         throw new TypeError('The requested investigation manifest entry was not found.');
-    const artifactValue = parseJson(artifactRaw);
+    const artifactValue = parseOfflineArtifactJson(artifactRaw);
     const metadata = artifactMetadata(artifactValue);
     const actualByteLength = inputBytes(artifactRaw);
     const expectedByteLength = Number(item.byteLength);
@@ -466,7 +511,7 @@ async function verifyManifestIdentity(artifactRaw, manifestRaw, entryId) {
             : 'mismatch';
     return Object.freeze({
         state,
-        manifest: Object.freeze({ schema: INVESTIGATION_MANIFEST_SCHEMA, version: INVESTIGATION_MANIFEST_VERSION, entryId }),
+        manifest: Object.freeze({ schema: INVESTIGATION_MANIFEST_SCHEMA, version: manifestReport.artifact.version, entryId }),
         checks,
         expectedByteLength,
         actualByteLength,
@@ -490,8 +535,9 @@ export async function verifyOfflineArtifact(raw, options = {}) {
 export function formatOfflineArtifactVerification(report) {
     const lines = [
         'WHOISleuth offline artefact verification',
-        `Artifact: ${report.artifact.kind} · ${report.artifact.schema} v${report.artifact.version}`,
+        `Artifact: ${report.artifact.kind} · ${report.artifact.schema ?? 'no schema identifier'} v${report.artifact.version}`,
         `State: ${report.state}`,
+        'Automation: use --strict-exit for exit 4 on incomplete verification; default exit 0 means the report was produced.',
         `Structure: ${report.checks.structure}`,
         `Content integrity: ${report.checks.contentIntegrity}`,
         `Content integrity scope: ${report.checks.contentIntegrityScope}`,
@@ -534,6 +580,28 @@ export function formatOfflineArtifactVerification(report) {
         for (const limitation of report.manifestIdentity.limitations)
             lines.push(`Manifest limitation: ${limitation}`);
     }
+    if (report.bagit) {
+        const bag = report.bagit;
+        lines.push(`BagIt: ${bag.state}`, `Payload: ${bag.entries.length} files; ${bag.payloadBytes} present bytes`, `Tag checksums: ${bag.verifiedTagFiles} of ${bag.tagFiles} tag files checked`, `Fetch declarations: ${bag.fetchEntries}; ${bag.fetchMissing} files missing; no requests made`, `Unsupported manifests: ${bag.unsupportedManifests}`);
+        for (const entry of bag.entries)
+            lines.push(`${entry.id}: ${entry.state} · ${entry.byteLength ?? 'unknown'} bytes`);
+        for (const issue of bag.issues)
+            lines.push(`BagIt issue: ${issue}`);
+    }
+    if (report.package) {
+        lines.push(`Package bytes: ${report.package.digestSha256}`, 'Storage: unchanged; inspection only', 'Audience: private; review selected file contents before sharing', 'Signature trust: not checked', 'Trusted timestamp: not checked', 'Factual accuracy: not established');
+        for (const entry of report.package.entries)
+            lines.push(`${entry.id}: ${entry.state} · ${entry.byteLength} bytes · ${entry.mediaType}${entry.issue ? ` · ${entry.issue}` : ''}`);
+        for (const link of report.package.links)
+            lines.push(`Source link ${link.capsuleEntryId}: ${link.state}${link.sourceEntryId ? ` (${link.sourceEntryId})` : ''}`);
+        for (const capture of report.package.captureManifests) {
+            lines.push(`Capture manifest ${capture.entryId}: ${capture.state}`);
+            for (const artifact of capture.artifacts)
+                lines.push(`Capture ${artifact.capture} ${artifact.kind}: ${artifact.state}${artifact.matchingIds.length ? ` (${artifact.matchingIds.join(', ')})` : ''}`);
+        }
+        for (const item of report.package.caseFiles)
+            lines.push(`Case files ${item.entryId} (${item.caseCount} Case${item.caseCount === 1 ? '' : 's'}): ${item.matched} of ${item.references} references matched; ${item.missing} missing`);
+    }
     for (const limitation of report.limitations)
         lines.push(`Limitation: ${limitation}`);
     return `${lines.join('\n')}\n`;

package/cli/assurance-arguments.mjs

@@ -0,0 +1,56 @@
+import {} from "./command-argument-grammar.mjs";
+import { CliUsageError } from "./errors.mjs";
+import { MAX_INVESTIGATION_MANIFEST_ARTIFACTS } from "../packages/contracts/investigation-package-limits.mjs";
+import { terminalOptions, jsonOutput, singleInputAction } from "./argument-values.mjs";
+function parseManifestArguments(parsed) {
+    const sources = parsed.positionalValues('artefacts');
+    if (sources.some((source) => !source))
+        throw new CliUsageError(`manifest requires from 1 to ${MAX_INVESTIGATION_MANIFEST_ARTIFACTS} artefact files.`);
+    if (new Set(sources).size !== sources.length)
+        throw new CliUsageError('manifest artefact files must be different.');
+    const configurationDigestSha256 = parsed.optionValue('--configuration-digest');
+    if (configurationDigestSha256 !== null && !/^sha256:[a-f0-9]{64}$/u.test(configurationDigestSha256)) {
+        throw new CliUsageError('--configuration-digest requires a sha256: hexadecimal digest.');
+    }
+    return {
+        action: 'manifest',
+        sources,
+        workflow: parsed.optionValue('--workflow'),
+        configurationDigestSha256,
+        ...(parsed.optionValue('--passphrase-file')
+            ? { passphraseSource: parsed.optionValue('--passphrase-file') }
+            : {}),
+        ...(parsed.hasOption('--package') ? { package: true } : {}),
+        ...(parsed.hasOption('--bagit') ? { bagit: true } : {}),
+        ...(parsed.optionValue('--folder') ? { folder: parsed.optionValue('--folder') } : {}),
+        output: jsonOutput(parsed),
+        ...terminalOptions(parsed),
+    };
+}
+function parseSharingReviewArguments(parsed) {
+    const purpose = parsed.optionValue('--purpose').replace(/\s+/gu, ' ').trim();
+    if (!purpose || purpose.length > 200)
+        throw new CliUsageError('--purpose is limited to 200 characters.');
+    return {
+        action: 'sharing-review',
+        source: parsed.positionalValue('source'),
+        output: jsonOutput(parsed),
+        marking: parsed.optionValue('--marking'),
+        recipientScope: parsed.optionValue('--recipient-scope'),
+        purpose,
+        humanReviewed: parsed.hasOption('--human-reviewed'),
+        personalDataReviewed: parsed.hasOption('--personal-data-reviewed'),
+        redactionsConfirmed: parsed.hasOption('--redactions-confirmed'),
+        ...terminalOptions(parsed),
+    };
+}
+export const ASSURANCE_ARGUMENT_PARSERS = Object.freeze({
+    manifest: parseManifestArguments,
+    'map-observations': (parsed) => singleInputAction('map-observations', parsed),
+    'oam-export': (parsed) => singleInputAction('oam-export', parsed),
+    'ct-intake': (parsed) => singleInputAction('ct-intake', parsed),
+    'domain-control': (parsed) => singleInputAction('domain-control', parsed),
+    assurance: (parsed) => singleInputAction('assurance', parsed),
+    'change-packet': (parsed) => singleInputAction('change-packet', parsed),
+    'sharing-review': parseSharingReviewArguments,
+});

package/cli/assurance-command-definitions.mjs

@@ -0,0 +1,179 @@
+import { MAX_INVESTIGATION_MANIFEST_ARTIFACTS, MAX_INVESTIGATION_MANIFEST_ARTIFACT_BYTES, MAX_INVESTIGATION_MANIFEST_TOTAL_BYTES } from "../packages/investigation/investigation-manifest.mjs";
+import { positional, OPTIONAL_FILE_POSITIONAL, constraint, EMPTY_CONSTRAINTS, commandSeed, flag, file } from "./command-definition.mjs";
+export const ASSURANCE_COMMAND_DEFINITIONS = Object.freeze({
+    manifest: commandSeed({
+        reference: {
+            description: `Record an ordered, path-free manifest for up to ${MAX_INVESTIGATION_MANIFEST_ARTIFACTS} local files. Use --package --output evidence.zip for a ZIP, add --passphrase-file to encrypt the ordinary package, or use --folder ./evidence for a new unencrypted folder. Add --bagit to ZIP or folder output for BagIt 1.0 with SHA-512 checksums.`,
+            example: 'whoisleuth manifest lookup.json comparison.json --workflow "domain review" --json',
+            boundary: 'Ordinary output contains metadata only. ZIP and folder output include unchanged selected bytes and are private until reviewed for sharing. Folders must be new; existing destinations are never replaced and a failed write may leave explicit partial output. BagIt output is unencrypted; its checksums do not authenticate evidence. Filenames ending in .json are parsed as JSON; other files are opaque and never executed. Original paths are omitted. No network request is made.',
+        },
+        collection: { scope: `Reads 1 to ${MAX_INVESTIGATION_MANIFEST_ARTIFACTS} local files, at most ${MAX_INVESTIGATION_MANIFEST_ARTIFACT_BYTES / 1024 / 1024} MiB each and ${MAX_INVESTIGATION_MANIFEST_TOTAL_BYTES.toLocaleString('en-AU')} bytes combined; retains no source paths.` },
+        summary: 'Build an evidence manifest offline',
+        options: ['--workflow', '--configuration-digest', '--package', '--bagit', '--passphrase-file', '--folder', '--json', '--quiet', '--no-color'],
+        optionOverrides: {
+            '--package': flag('Create a portable evidence ZIP containing the selected files.'),
+            '--folder': file('Create a new evidence folder containing the selected files.'),
+            '--bagit': flag('Create a BagIt 1.0 package with SHA-512 checksums.'),
+        },
+        positionals: Object.freeze([positional('artefacts', 'file', 1, MAX_INVESTIGATION_MANIFEST_ARTIFACTS)]),
+        constraints: Object.freeze([
+            constraint({ kind: 'required', options: ['--workflow'] }),
+            constraint({ kind: 'requires_any', option: '--bagit', requiredOptions: ['--package', '--folder'] }),
+            constraint({ kind: 'excludes_all', option: '--bagit', excludedOptions: ['--passphrase-file'] }),
+            constraint({ kind: 'requires_all', option: '--package', requiredOptions: ['--output'] }),
+            constraint({ kind: 'requires_all', option: '--passphrase-file', requiredOptions: ['--package'] }),
+            constraint({ kind: 'mutually_exclusive', options: ['--package', '--json'] }),
+            constraint({ kind: 'excludes_all', option: '--folder', excludedOptions: ['--package', '--output', '--force'] }),
+        ]),
+        handlerOwner: 'assurance',
+        networkEffect: 'offline',
+        common: false,
+        schemaIdentifiers: Object.freeze(['whoisleuth.investigation-manifest']),
+        primaryArtefacts: Object.freeze([]),
+        planSupport: false,
+        additionalOutputFormats: Object.freeze([]),
+        bootstrapProfile: 'allowed',
+    }),
+    "map-observations": commandSeed({
+        reference: {
+            description: 'Apply one bounded declarative field-mapping profile to local source observations.',
+            example: 'whoisleuth map-observations mapping.json --json',
+            boundary: 'Profiles select allowlisted dotted fields only. They execute no scripts, make no requests, and emit the browser-compatible external-findings contract.',
+        },
+        collection: { scope: 'Reads one mapping document capped at 4 MiB and executes no scripts or requests.' },
+        summary: 'Apply a declarative observation map offline',
+        options: ['--json', '--quiet', '--no-color'],
+        positionals: OPTIONAL_FILE_POSITIONAL,
+        constraints: EMPTY_CONSTRAINTS,
+        handlerOwner: 'assurance',
+        networkEffect: 'offline',
+        common: false,
+        schemaIdentifiers: Object.freeze(['whoisleuth.external-observation-mapping']),
+        primaryArtefacts: Object.freeze([]),
+        planSupport: false,
+        additionalOutputFormats: Object.freeze([]),
+        bootstrapProfile: 'allowed',
+    }),
+    "oam-export": commandSeed({
+        reference: {
+            description: 'Project browser-compatible external findings into a bounded Open Asset Model bridge document.',
+            example: 'whoisleuth oam-export external-findings.json --json',
+            boundary: 'The projection is offline, preserves source completeness without inventing confidence, and covers only bounded FQDN, IP address, certificate, and related edge vocabulary.',
+        },
+        collection: { scope: 'Reads one browser-compatible external-findings document and projects bounded graph records locally.' },
+        summary: 'Project external findings to Open Asset Model',
+        options: ['--json', '--quiet', '--no-color'],
+        positionals: OPTIONAL_FILE_POSITIONAL,
+        constraints: EMPTY_CONSTRAINTS,
+        handlerOwner: 'assurance',
+        networkEffect: 'offline',
+        common: false,
+        schemaIdentifiers: Object.freeze(['whoisleuth.open-asset-model-bridge']),
+        primaryArtefacts: Object.freeze([]),
+        planSupport: false,
+        additionalOutputFormats: Object.freeze([]),
+        bootstrapProfile: 'allowed',
+    }),
+    "ct-intake": commandSeed({
+        reference: {
+            description: 'Normalise source-qualified local certificate events into browser-compatible findings.',
+            example: 'whoisleuth ct-intake certificate-events.json --json',
+            boundary: 'The command is offline, caps output at 100 findings, and treats every event as a review lead rather than proof of serving or control.',
+        },
+        collection: { scope: 'Reads one source-qualified event batch capped at 4 MiB and makes no request.' },
+        summary: 'Normalise certificate observations offline',
+        options: ['--json', '--quiet', '--no-color'],
+        positionals: OPTIONAL_FILE_POSITIONAL,
+        constraints: EMPTY_CONSTRAINTS,
+        handlerOwner: 'assurance',
+        networkEffect: 'offline',
+        common: false,
+        schemaIdentifiers: Object.freeze(['whoisleuth.ct-event-batch', 'whoisleuth.external-findings']),
+        primaryArtefacts: Object.freeze([]),
+        planSupport: false,
+        additionalOutputFormats: Object.freeze([]),
+        bootstrapProfile: 'allowed',
+    }),
+    "domain-control": commandSeed({
+        reference: {
+            description: 'Build an integrity-protected desired-state manifest or compare one with supplied observations.',
+            example: 'whoisleuth domain-control domain-control-input.json --json',
+            boundary: 'The command is offline and changes no registrar, DNS, mail, or certificate configuration. Only complete, recent source observations can establish drift or expected absence.',
+        },
+        collection: { scope: 'Reads one bounded desired-state or review document and performs no collection or configuration change.' },
+        summary: 'Build or review a domain control manifest',
+        options: ['--json', '--quiet', '--no-color'],
+        positionals: OPTIONAL_FILE_POSITIONAL,
+        constraints: EMPTY_CONSTRAINTS,
+        handlerOwner: 'assurance',
+        networkEffect: 'offline',
+        common: false,
+        schemaIdentifiers: Object.freeze(['whoisleuth.cli.domain-control-review-input', 'whoisleuth.cli.domain-control-review']),
+        primaryArtefacts: Object.freeze([]),
+        planSupport: false,
+        additionalOutputFormats: Object.freeze([]),
+        bootstrapProfile: 'allowed',
+    }),
+    assurance: commandSeed({
+        reference: {
+            description: 'Review a versioned domain change, recovery-dependency, or retirement plan.',
+            example: 'whoisleuth assurance domain-assurance.json --json',
+            boundary: 'The command is offline and treats every provider label, readiness state, and evidence reference as analyst-authored input. It changes no configuration.',
+        },
+        collection: { scope: 'Reads one versioned plan capped at 2 MiB and makes no request or configuration change.' },
+        summary: 'Review domain change, recovery, or retirement plans',
+        options: ['--json', '--quiet', '--no-color'],
+        positionals: OPTIONAL_FILE_POSITIONAL,
+        constraints: EMPTY_CONSTRAINTS,
+        handlerOwner: 'assurance',
+        networkEffect: 'offline',
+        common: false,
+        schemaIdentifiers: Object.freeze(['whoisleuth.domain-assurance.input', 'whoisleuth.domain-assurance']),
+        primaryArtefacts: Object.freeze([]),
+        planSupport: false,
+        additionalOutputFormats: Object.freeze([]),
+        bootstrapProfile: 'allowed',
+    }),
+    "change-packet": commandSeed({
+        reference: {
+            description: 'Assemble pre-change, post-change, and planning evidence into one integrity-protected packet.',
+            example: 'whoisleuth change-packet change-review.json --json',
+            boundary: 'Assembly is offline. Readiness reflects only the supplied bounded evidence and does not authorise or perform a domain change.',
+        },
+        collection: { scope: 'Reads one versioned packet input capped at 6 MiB and makes no request or configuration change.' },
+        summary: 'Build a reviewed change packet offline',
+        options: ['--json', '--quiet', '--no-color'],
+        positionals: OPTIONAL_FILE_POSITIONAL,
+        constraints: EMPTY_CONSTRAINTS,
+        handlerOwner: 'assurance',
+        networkEffect: 'offline',
+        common: false,
+        schemaIdentifiers: Object.freeze(['whoisleuth.domain-change-packet.input', 'whoisleuth.domain-change-packet']),
+        primaryArtefacts: Object.freeze([]),
+        planSupport: false,
+        additionalOutputFormats: Object.freeze([]),
+        bootstrapProfile: 'allowed',
+    }),
+    "sharing-review": commandSeed({
+        reference: {
+            description: 'Lint one reviewed artefact against local integrity, marking, recipient, personal-data, and redaction controls.',
+            example: 'whoisleuth sharing-review packet.json --marking amber --recipient-scope organization --purpose "Reviewed incident handoff" --human-reviewed --personal-data-reviewed --redactions-confirmed --json',
+            boundary: 'The command is offline and emits only bounded schema/version metadata, no content values, and no raw evidence. Its result is a review aid, not legal advice or recipient authorisation.',
+        },
+        collection: { scope: 'Reads one bounded artefact, emits only schema/version metadata and no content values, and performs no transmission.' },
+        summary: 'Lint an artefact before deliberate sharing',
+        options: ['--marking', '--recipient-scope', '--purpose', '--human-reviewed', '--personal-data-reviewed', '--redactions-confirmed', '--json', '--quiet', '--no-color'],
+        positionals: OPTIONAL_FILE_POSITIONAL,
+        constraints: Object.freeze([
+            constraint({ kind: 'required', options: ['--marking', '--recipient-scope', '--purpose'] }),
+        ]),
+        handlerOwner: 'assurance',
+        networkEffect: 'offline',
+        common: false,
+        schemaIdentifiers: Object.freeze(['whoisleuth.cli.sharing-review']),
+        primaryArtefacts: Object.freeze([]),
+        planSupport: false,
+        additionalOutputFormats: Object.freeze([]),
+        bootstrapProfile: 'allowed',
+    }),
+});

package/cli/assurance-command-runner.mjs

@@ -1,5 +1,10 @@
 import { Buffer } from 'node:buffer';
-import { scanBoundedJson } from "../lib/bounded-json.mjs";
+import { readBoundedRegularFile } from "../lib/bounded-file.mjs";
+import { buildInvestigationPackage } from "../packages/investigation/investigation-package.mjs";
+import { encryptInvestigationPackage } from "../packages/investigation/investigation-package-crypto.mjs";
+import { writeInvestigationFolder, writePreparedEvidenceFolder } from "./investigation-folder.mjs";
+import { buildInvestigationBagIt, prepareInvestigationBagIt } from "../packages/investigation/investigation-bagit.mjs";
+import { scanBoundedJson } from "../packages/analysis/bounded-json.mjs";
 import { MAX_ASSURANCE_INPUT_BYTES, buildDomainAssurance, formatDomainAssurance, } from "../lib/domain-assurance.mjs";
 import { MAX_DOMAIN_CHANGE_PACKET_INPUT_BYTES, buildDomainChangePacket, formatDomainChangePacket, } from "../lib/domain-change-packet.mjs";
 import { DOMAIN_CONTROL_FLIGHT_RECORDER_INPUT_SCHEMA, buildDomainControlFlightRecorder, formatDomainControlFlightRecorder, serializeDomainControlFlightRecorder, } from "../lib/domain-control-flight-recorder.mjs";
@@ -12,7 +17,7 @@ import { boundedCliErrorMessage, CliUsageError } from "./errors.mjs";
 import EXIT_CODES from "./exit-codes.mjs";
 import { MAX_EXTERNAL_OBSERVATION_MAPPING_BYTES, formatExternalObservationMapping, mapExternalObservations, } from "./external-observation-mapping.mjs";
 import { formatJsonDocument } from "./formatters/json.mjs";
-import { MAX_INVESTIGATION_MANIFEST_ARTIFACT_BYTES, MAX_INVESTIGATION_MANIFEST_TOTAL_BYTES, buildInvestigationManifest, formatInvestigationManifest, } from "./investigation-manifest.mjs";
+import { MAX_INVESTIGATION_MANIFEST_ARTIFACT_BYTES, MAX_INVESTIGATION_MANIFEST_TOTAL_BYTES, buildInvestigationManifest, formatInvestigationManifest, investigationFileMediaType, } from "./investigation-manifest.mjs";
 import { buildOpenAssetModelBridge, formatOpenAssetModelBridge, } from "./open-asset-model-bridge.mjs";
 import { ASSURANCE_INLINE_COMMANDS } from "./inline-command-families.mjs";
 import { MAX_SHARING_REVIEW_BYTES, buildSharingReview, formatSharingReview, } from "./sharing-review.mjs";
@@ -23,6 +28,15 @@ async function runManifestCommand(args, dependencies, context) {
     let totalBytes = 0;
     try {
         for (const source of args.sources) {
+            if (args.package || args.folder) {
+                const content = dependencies.readBinaryArtifactInput ? await dependencies.readBinaryArtifactInput(source)
+                    : await readBoundedRegularFile(source, { maximumBytes: MAX_INVESTIGATION_MANIFEST_ARTIFACT_BYTES, minimumBytes: 1, label: 'Package artefact input', ...(dependencies.signal ? { signal: dependencies.signal } : {}) });
+                if (content.byteLength > MAX_INVESTIGATION_MANIFEST_TOTAL_BYTES - totalBytes)
+                    throw new CliUsageError('Package artefacts exceed the combined byte limit.');
+                totalBytes += content.byteLength;
+                artifacts.push({ content, mediaType: investigationFileMediaType(source) });
+                continue;
+            }
             const content = dependencies.readDiffInput
                 ? await dependencies.readDiffInput(source)
                 : await context.readInput(source, MAX_INVESTIGATION_MANIFEST_ARTIFACT_BYTES, 'Manifest artefact input');
@@ -40,11 +54,32 @@ async function runManifestCommand(args, dependencies, context) {
     }
     let document;
     try {
-        document = await buildInvestigationManifest({
+        if (args.package) {
+            const built = await (args.bagit ? buildInvestigationBagIt : buildInvestigationPackage)({ workflow: args.workflow, configurationDigestSha256: args.configurationDigestSha256, artifacts }, context.now(), context.packageVersion);
+            dependencies.signal?.throwIfAborted();
+            if (!context.writeBinaryOutput)
+                throw new CliUsageError('Package output requires an explicit file destination.');
+            const output = args.passphraseSource
+                ? await encryptInvestigationPackage(built.bytes, await context.readPassphraseSource(args.passphraseSource))
+                : built.bytes;
+            dependencies.signal?.throwIfAborted();
+            context.writeBinaryOutput(output);
+            return EXIT_CODES.SUCCESS;
+        }
+        const input = {
             workflow: args.workflow,
             configurationDigestSha256: args.configurationDigestSha256,
             artifacts,
-        }, context.now(), context.packageVersion);
+        };
+        if (args.bagit && args.folder) {
+            const prepared = await prepareInvestigationBagIt(input, context.now(), context.packageVersion);
+            await writePreparedEvidenceFolder(args.folder, prepared.files, 'data', 'tagmanifest-sha512.txt', dependencies.signal);
+            document = prepared.manifest;
+        }
+        else
+            document = args.folder
+                ? await writeInvestigationFolder(args.folder, input, context.now(), context.packageVersion, dependencies.signal)
+                : await buildInvestigationManifest(input, context.now(), context.packageVersion);
     }
     catch (error) {
         throw new CliUsageError(boundedCliErrorMessage(error, 'Investigation manifest input is invalid'));
@@ -52,7 +87,7 @@ async function runManifestCommand(args, dependencies, context) {
     if (!args.quiet) {
         context.writeStdout(args.output === 'json'
             ? formatJsonDocument(document)
-            : context.terminal(formatInvestigationManifest(document), args.color));
+            : context.terminal(`${args.folder ? 'Created a new private evidence folder.\n' : ''}${formatInvestigationManifest(document)}`, args.color));
     }
     return EXIT_CODES.SUCCESS;
 }

package/cli/bagit-folder.mjs

@@ -0,0 +1,57 @@
+import { lstat, opendir, realpath } from 'node:fs/promises';
+import { join } from 'node:path';
+import { readBoundedRegularFileWithin } from "../lib/bounded-file.mjs";
+import { assertBagItSelection, bagItPath, bagItEntryMaximum, MAX_BAGIT_ENTRIES } from "../packages/interchange/bagit.mjs";
+import { selectedEvidenceDirectory, evidenceDirectoryIdentity } from "./investigation-folder.mjs";
+/** Bounded recursive enumeration; no symbolic links, special files or writes. */
+export async function readBagItFolder(value, signal) {
+    const selected = selectedEvidenceDirectory(value);
+    const identity = await evidenceDirectoryIdentity(selected), root = await realpath(selected);
+    const directories = new Map([['', identity]]);
+    const entries = [];
+    const visit = async (relative) => {
+        signal?.throwIfAborted();
+        const path = join(root, relative);
+        if (await realpath(path) !== path)
+            throw new TypeError('BagIt directories must not contain symbolic links.');
+        for await (const item of await opendir(path)) {
+            signal?.throwIfAborted();
+            if (entries.length >= MAX_BAGIT_ENTRIES)
+                throw new TypeError('BagIt exceeds its entry limit.');
+            const name = `${relative ? `${relative}/` : ''}${item.name}`;
+            bagItPath(item.isDirectory() ? `${name}/` : name);
+            const stat = await lstat(join(root, name));
+            if (item.isDirectory() && stat.isDirectory() && !stat.isSymbolicLink()) {
+                directories.set(name, await evidenceDirectoryIdentity(join(root, name)));
+                entries.push({ path: `${name}/`, byteLength: 0 });
+                await visit(name);
+            }
+            else if (item.isFile() && stat.isFile() && !stat.isSymbolicLink()) {
+                if (stat.size > bagItEntryMaximum(name))
+                    throw new TypeError('BagIt entry exceeds its byte limit.');
+                entries.push({ path: name, byteLength: stat.size });
+            }
+            else
+                throw new TypeError('BagIt entries must be ordinary files and directories, not symbolic links or special files.');
+        }
+    };
+    await visit('');
+    assertBagItSelection(entries);
+    const files = new Map();
+    for (const entry of entries) {
+        signal?.throwIfAborted();
+        files.set(entry.path, entry.path.endsWith('/') ? new Uint8Array() : await readBoundedRegularFileWithin(root, entry.path, {
+            maximumBytes: bagItEntryMaximum(entry.path), minimumBytes: 0, expectedBytes: entry.byteLength,
+            label: 'BagIt file', ...(signal ? { signal } : {}),
+        }));
+    }
+    for (const [path, before] of directories) {
+        signal?.throwIfAborted();
+        const currentPath = path ? join(root, path) : selected;
+        const after = await evidenceDirectoryIdentity(currentPath);
+        if (await realpath(currentPath) !== join(root, path) || before.device !== after.device || before.inode !== after.inode
+            || before.modified !== after.modified || before.changed !== after.changed)
+            throw new TypeError('BagIt folder changed while it was read.');
+    }
+    return files;
+}

package/cli/bagit-review.mjs

@@ -0,0 +1,23 @@
+import { inspectBagItEntries, readBagItZip } from "../packages/interchange/bagit.mjs";
+import { OFFLINE_ARTIFACT_VERIFICATION_SCHEMA, OFFLINE_ARTIFACT_VERIFICATION_VERSION } from "./artifact-verify.mjs";
+export async function verifyOfflineBagIt(input) {
+    const files = input instanceof Uint8Array ? readBagItZip(input) : input;
+    const zipBytes = input instanceof Uint8Array ? input.byteLength : null;
+    const { review, inputBytes } = await inspectBagItEntries(files);
+    return {
+        schema: OFFLINE_ARTIFACT_VERIFICATION_SCHEMA, version: OFFLINE_ARTIFACT_VERIFICATION_VERSION,
+        artifact: { kind: 'bagit', schema: null, version: '1.0' },
+        state: review.state === 'valid' ? 'integrity_valid' : 'partial',
+        checks: { structure: review.complete ? 'verified' : 'failed',
+            contentIntegrity: review.state === 'valid' ? 'verified' : review.state === 'invalid' ? 'failed' : 'not_checked',
+            contentIntegrityScope: 'manifest_and_files', authenticatedEncryption: 'not_applicable' },
+        summary: { inputBytes: zipBytes ?? inputBytes,
+            sectionCount: null, recordCount: review.entries.length, ciphertextBytes: null },
+        manifestIdentity: null, bagit: review,
+        limitations: [
+            'BagIt verifies declared file checksums, not payload schemas, factual accuracy, source identity, signatures or trusted timestamps.',
+            'Tag files without a checksum are not integrity-checked. No file is imported, executed or fetched; fetch.txt locations and original paths are omitted from this report.',
+            'This bounded reader supports BagIt 1.0, UTF-8 text tags, SHA-256 and SHA-512, portable relative paths and the selected-file byte limits. Other encodings, algorithms and unsafe or platform-ambiguous paths are not silently accepted.',
+        ],
+    };
+}