@slicedearth/whoisleuth-cli 1.45.0 → 2.0.0

package/{frontend/src/lib/analysis/workspace-archive.js → packages/workspace/workspace-archive.mjs}

@@ -1,58 +1,44 @@
 // Pure, bounded workspace archive composition. Existing typed store models remain the
 // authority for normalization and merge semantics; this module only packages
 // their portable contracts, verifies integrity, and previews conflicts.
-import { buildCaseExport, CASE_SCHEMA_VERSION, enforceStoreBudget, mergeCases, } from "./case-model.js";
-import { assertBrandProfileStoreBudget, BRAND_PROFILE_SCHEMA, BRAND_PROFILE_SCHEMA_VERSION, buildBrandProfileExport, mergeBrandProfiles, normalizeBrandProfileId, } from "./brand-profile-model.js";
-import { assertCampaignStoreBudget, buildCampaignExport, CAMPAIGN_SCHEMA, CAMPAIGN_SCHEMA_VERSION, mergeCampaigns, } from "./campaign-model.js";
-import { assertWatchlistStoreBudget, buildWatchlistExport, mergeWatchlistStores, WATCHLIST_SCHEMA, WATCHLIST_SCHEMA_VERSION, } from "./watchlist-store.js";
-import { assertShortlistStoreBudget, buildShortlistExport, mergeShortlistStores, SHORTLIST_SCHEMA, SHORTLIST_SCHEMA_VERSION, } from "./shortlist-model.js";
-import { assertDetectionRuleStoreBudget, buildDetectionRuleExport, DETECTION_RULE_SCHEMA, DETECTION_RULE_SCHEMA_VERSION, mergeDetectionRules, } from "./detection-rule-model.js";
-import { buildRelationshipObservationExport, mergeRelationshipObservations, RELATIONSHIP_OBSERVATION_SCHEMA, RELATIONSHIP_OBSERVATION_SCHEMA_VERSION, } from "./relationship-observation-model.js";
-import { BULK_SESSION_SCHEMA, BULK_SESSION_SCHEMA_VERSION, buildBulkSessionExport, enforceBulkSessionStoreBudget, mergeBulkSessions, } from "./bulk-session-model.js";
-import { WEBSITE_SNAPSHOT_SCHEMA, WEBSITE_SNAPSHOT_SCHEMA_VERSION, buildWebsiteSnapshotExport, mergeWebsiteSnapshots, } from "./website-snapshot-model.js";
-import { INVESTIGATION_TEMPLATE_SCHEMA, INVESTIGATION_TEMPLATE_VERSION, buildInvestigationTemplateExport, mergeInvestigationTemplates, } from "./investigation-template-model.js";
-import { BULK_REVIEW_SCHEMA, BULK_REVIEW_SCHEMA_VERSION, buildBulkReviewExport, mergeBulkReviewStores, } from "./bulk-review-model.js";
-export const WORKSPACE_ARCHIVE_SCHEMA = 'whoisleuth.workspace-archive';
-export const WORKSPACE_ARCHIVE_VERSION = 5;
-export const SUPPORTED_WORKSPACE_ARCHIVE_VERSIONS = [1, 2, 3, 4, WORKSPACE_ARCHIVE_VERSION];
-export const WORKSPACE_SETTINGS_SCHEMA = 'whoisleuth.workspace-settings';
-export const WORKSPACE_SETTINGS_VERSION = 1;
-export const MAX_WORKSPACE_ARCHIVE_BYTES = 10 * 1024 * 1024;
-export const MAX_WORKSPACE_ARCHIVE_SECTION_BYTES = 5 * 1024 * 1024;
-export const MAX_WORKSPACE_ARCHIVE_SECTIONS = 12;
-export const WORKSPACE_ARCHIVE_SECTION_IDS = [
-    'cases',
-    'campaigns',
-    'brandProfiles',
-    'watchlists',
-    'shortlist',
-    'detectionRules',
-    'relationshipObservations',
-    'bulkSessions',
-    'websiteSnapshots',
-    'investigationTemplates',
-    'bulkReview',
-    'settings',
-];
-export function isSupportedWorkspaceArchiveVersion(value) {
-    return typeof value === 'number'
-        && Number.isSafeInteger(value)
-        && SUPPORTED_WORKSPACE_ARCHIVE_VERSIONS.some((version) => version === value);
-}
+import { buildCaseExport, enforceStoreBudget, mergeCases, } from "../cases/case-model.mjs";
+import { assertBrandProfileStoreBudget, buildBrandProfileExport, mergeBrandProfiles, normalizeBrandProfileId, } from "./brand-profile-model.mjs";
+import { assertCampaignStoreBudget, buildCampaignExport, mergeCampaigns, } from "./campaign-model.mjs";
+import { normalizeExplicitIsoTimestamp } from "../evidence/observation.mjs";
+import { assertWorkspaceInputGraph } from "./hostile-input.mjs";
+import { assertWatchlistStoreBudget, buildWatchlistExport, mergeWatchlistStores, } from "./watchlist-store.mjs";
+import { assertShortlistStoreBudget, buildShortlistExport, mergeShortlistStores, } from "./shortlist-model.mjs";
+import { assertDetectionRuleStoreBudget, buildDetectionRuleExport, mergeDetectionRules, } from "./detection-rule-model.mjs";
+import { buildRelationshipObservationExport, mergeRelationshipObservations, } from "./relationship-observation-model.mjs";
+import { buildBulkSessionExport, enforceBulkSessionStoreBudget, mergeBulkSessions, } from "./bulk-session-model.mjs";
+import { buildWebsiteSnapshotExport, mergeWebsiteSnapshots, } from "./website-snapshot-model.mjs";
+import { buildInvestigationTemplateExport, mergeInvestigationTemplates, } from "./investigation-template-model.mjs";
+import { buildBulkReviewExport, mergeBulkReviewStores, } from "./bulk-review-model.mjs";
+import { buildAnalystReviewStateExport, emptyAnalystReviewStateStore, mergeAnalystReviewStateStores, } from "../monitoring/analyst-review-state.mjs";
+import { isSupportedWorkspaceArchiveVersion, MAX_WORKSPACE_ARCHIVE_BYTES, MAX_WORKSPACE_ARCHIVE_SECTION_BYTES, MAX_WORKSPACE_ARCHIVE_SECTIONS, serialiseWorkspaceArchiveSection, SUPPORTED_WORKSPACE_ARCHIVE_VERSIONS, WORKSPACE_ARCHIVE_CASE_SECTION, WORKSPACE_ARCHIVE_SCHEMA, WORKSPACE_ARCHIVE_SECTION_IDS, PUBLIC_WORKSPACE_ARCHIVE_SECTION_IDS, PUBLIC_WORKSPACE_ARCHIVE_VERSION, WORKSPACE_ARCHIVE_VERSION, WORKSPACE_SETTINGS_COMPATIBILITY, WORKSPACE_SETTINGS_SCHEMA, WORKSPACE_SETTINGS_VERSION, } from "../contracts/case-portability.mjs";
+import { ANALYST_REVIEW_STATE_COMPATIBILITY } from "../contracts/analyst-review-state.mjs";
+import { WORKSPACE_PORTABILITY_ARCHIVE_SECTION_REFERENCES } from "../contracts/workspace-portability.mjs";
+export { isSupportedWorkspaceArchiveVersion, MAX_WORKSPACE_ARCHIVE_BYTES, MAX_WORKSPACE_ARCHIVE_SECTION_BYTES, MAX_WORKSPACE_ARCHIVE_SECTIONS, SUPPORTED_WORKSPACE_ARCHIVE_VERSIONS, WORKSPACE_ARCHIVE_CASE_SECTION, WORKSPACE_ARCHIVE_SCHEMA, WORKSPACE_ARCHIVE_SECTION_IDS, PUBLIC_WORKSPACE_ARCHIVE_SECTION_IDS, PUBLIC_WORKSPACE_ARCHIVE_VERSION, WORKSPACE_ARCHIVE_VERSION, WORKSPACE_SETTINGS_SCHEMA, WORKSPACE_SETTINGS_VERSION, };
 const CONTROL_RE = /[\x00-\x1f\x7f]/;
 const CHECKSUM_RE = /^sha256:[a-f0-9]{64}$/;
+const WORKSPACE_ARCHIVE_ROOT_KEYS = Object.freeze(['schema', 'version', 'generatedAt', 'manifest', 'sections', 'limitations']);
+const WORKSPACE_ARCHIVE_MANIFEST_KEYS = Object.freeze(['sectionCount', 'totalRecords', 'sections']);
+const WORKSPACE_ARCHIVE_MANIFEST_ENTRY_KEYS = Object.freeze(['id', 'schema', 'version', 'recordCount', 'bytes', 'checksum']);
 function record(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
 }
+function assertExactKeys(value, expected, label) {
+    const keys = Object.keys(value);
+    if (keys.length !== expected.length || keys.some((key) => !expected.includes(key))) {
+        throw new Error(`The workspace archive ${label} contains missing or undeclared fields.`);
+    }
+}
 function byteLength(value) {
     return new TextEncoder().encode(value).byteLength;
 }
 function serialize(value, message = 'The workspace archive contains data that cannot be serialised.') {
     try {
-        const serialized = JSON.stringify(value);
-        if (typeof serialized !== 'string')
-            throw new Error(message);
-        return serialized;
+        return serialiseWorkspaceArchiveSection(value);
     }
     catch {
         throw new Error(message);
@@ -62,10 +48,10 @@ function clone(value) {
     return JSON.parse(serialize(value));
 }
 function timestamp(value, fallback = null) {
-    if (typeof value !== 'string' || value.length > 64 || CONTROL_RE.test(value))
-        return fallback;
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : fallback;
+    const explicit = normalizeExplicitIsoTimestamp(value);
+    if (explicit)
+        return explicit;
+    return fallback;
 }
 function boundedText(value, maximum = 300) {
     if (typeof value !== 'string' || value.length > maximum * 4 || CONTROL_RE.test(value))
@@ -124,6 +110,7 @@ function workspaceArchiveSections(input, now) {
         websiteSnapshots: buildWebsiteSnapshotExport(input.websiteSnapshots, now),
         investigationTemplates: buildInvestigationTemplateExport(input.investigationTemplates, now),
         bulkReview: buildBulkReviewExport(input.bulkReview),
+        analystReviewState: buildAnalystReviewStateExport(input.analystReviewState),
         settings: settingsDocument(input),
     };
 }
@@ -136,9 +123,29 @@ function objectCount(data, key) {
     const nested = value ? record(value[key]) : null;
     return nested ? Object.keys(nested).length : 0;
 }
+function sectionContract(sectionId) {
+    const reference = WORKSPACE_PORTABILITY_ARCHIVE_SECTION_REFERENCES.find((entry) => entry.sectionId === sectionId);
+    if (!reference)
+        throw new TypeError(`Workspace archive section ${sectionId} has no canonical contract reference.`);
+    return Object.freeze({
+        id: reference.sectionId,
+        schema: reference.schema,
+        version: reference.version,
+        supportedVersions: reference.supportedVersions,
+    });
+}
+function compatibilitySchema(descriptor) {
+    if (!descriptor.schema)
+        throw new TypeError(`Workspace compatibility ${descriptor.id} must name a schema.`);
+    return descriptor.schema;
+}
 const SECTION_DEFINITIONS = [
     {
-        id: 'cases', label: 'Cases', schema: null, version: CASE_SCHEMA_VERSION,
+        id: WORKSPACE_ARCHIVE_CASE_SECTION.id,
+        label: 'Cases',
+        schema: WORKSPACE_ARCHIVE_CASE_SECTION.schema,
+        version: WORKSPACE_ARCHIVE_CASE_SECTION.currentVersion,
+        supportedVersions: WORKSPACE_ARCHIVE_CASE_SECTION.supportedVersions,
         count: (data) => arrayCount(data, 'cases'),
         merge: (local, data) => {
             const result = mergeCases(local.cases, data);
@@ -147,7 +154,7 @@ const SECTION_DEFINITIONS = [
         },
     },
     {
-        id: 'campaigns', label: 'Campaigns', schema: CAMPAIGN_SCHEMA, version: CAMPAIGN_SCHEMA_VERSION,
+        ...sectionContract('campaigns'), label: 'Campaigns',
         count: (data) => arrayCount(data, 'campaigns'),
         merge: (local, data) => {
             const result = mergeCampaigns(local.campaigns, data);
@@ -155,7 +162,7 @@ const SECTION_DEFINITIONS = [
         },
     },
     {
-        id: 'brandProfiles', label: 'Brand profiles', schema: BRAND_PROFILE_SCHEMA, version: BRAND_PROFILE_SCHEMA_VERSION,
+        ...sectionContract('brandProfiles'), label: 'Brand profiles',
         count: (data) => arrayCount(data, 'profiles'),
         merge: (local, data, now) => {
             const result = mergeBrandProfiles(local.brandProfiles, data, { nowIso: now });
@@ -163,7 +170,7 @@ const SECTION_DEFINITIONS = [
         },
     },
     {
-        id: 'watchlists', label: 'Watchlists', schema: WATCHLIST_SCHEMA, version: WATCHLIST_SCHEMA_VERSION,
+        ...sectionContract('watchlists'), label: 'Watchlists',
         count: (data) => objectCount(data, 'watchlists'),
         merge: (local, data) => {
             const result = mergeWatchlistStores(local.watchlists, data);
@@ -171,7 +178,7 @@ const SECTION_DEFINITIONS = [
         },
     },
     {
-        id: 'shortlist', label: 'Shortlist', schema: SHORTLIST_SCHEMA, version: SHORTLIST_SCHEMA_VERSION,
+        ...sectionContract('shortlist'), label: 'Shortlist',
         count: (data) => arrayCount(data, 'entries'),
         merge: (local, data) => {
             const result = mergeShortlistStores(local.shortlist, data);
@@ -179,7 +186,7 @@ const SECTION_DEFINITIONS = [
         },
     },
     {
-        id: 'detectionRules', label: 'Detection rules', schema: DETECTION_RULE_SCHEMA, version: DETECTION_RULE_SCHEMA_VERSION,
+        ...sectionContract('detectionRules'), label: 'Detection rules',
         count: (data) => arrayCount(data, 'rules'),
         merge: (local, data) => {
             const result = mergeDetectionRules(local.detectionRules, data);
@@ -187,18 +194,14 @@ const SECTION_DEFINITIONS = [
         },
     },
     {
-        id: 'relationshipObservations',
+        ...sectionContract('relationshipObservations'),
         label: 'Retained relationship observations',
-        schema: RELATIONSHIP_OBSERVATION_SCHEMA,
-        version: RELATIONSHIP_OBSERVATION_SCHEMA_VERSION,
         count: (data) => arrayCount(data, 'observations'),
         merge: (local, data) => mergeRelationshipObservations(local.relationshipObservations, data),
     },
     {
-        id: 'bulkSessions',
+        ...sectionContract('bulkSessions'),
         label: 'Saved Bulk sessions',
-        schema: BULK_SESSION_SCHEMA,
-        version: BULK_SESSION_SCHEMA_VERSION,
         count: (data) => arrayCount(data, 'sessions'),
         merge: (local, data) => {
             const result = mergeBulkSessions(local.bulkSessions, data);
@@ -207,31 +210,36 @@ const SECTION_DEFINITIONS = [
         },
     },
     {
-        id: 'websiteSnapshots',
+        ...sectionContract('websiteSnapshots'),
         label: 'Website profile snapshots',
-        schema: WEBSITE_SNAPSHOT_SCHEMA,
-        version: WEBSITE_SNAPSHOT_SCHEMA_VERSION,
         count: (data) => arrayCount(data, 'snapshots'),
         merge: (local, data) => mergeWebsiteSnapshots(local.websiteSnapshots, data),
     },
     {
-        id: 'investigationTemplates',
+        ...sectionContract('investigationTemplates'),
         label: 'Investigation templates',
-        schema: INVESTIGATION_TEMPLATE_SCHEMA,
-        version: INVESTIGATION_TEMPLATE_VERSION,
         count: (data) => arrayCount(data, 'templates'),
         merge: (local, data) => mergeInvestigationTemplates(local.investigationTemplates, data),
     },
     {
-        id: 'bulkReview',
+        ...sectionContract('bulkReview'),
         label: 'Bulk saved views and review queue',
-        schema: BULK_REVIEW_SCHEMA,
-        version: BULK_REVIEW_SCHEMA_VERSION,
         count: (data) => arrayCount(data, 'presets') + arrayCount(data, 'rows'),
         merge: (local, data) => mergeBulkReviewStores(local.bulkReview, data),
     },
     {
-        id: 'settings', label: 'Workspace settings', schema: WORKSPACE_SETTINGS_SCHEMA, version: WORKSPACE_SETTINGS_VERSION,
+        id: 'analystReviewState',
+        label: 'Analyst Review Item lifecycle',
+        schema: compatibilitySchema(ANALYST_REVIEW_STATE_COMPATIBILITY),
+        version: ANALYST_REVIEW_STATE_COMPATIBILITY.currentVersion,
+        supportedVersions: ANALYST_REVIEW_STATE_COMPATIBILITY.supportedVersions,
+        count: (data) => arrayCount(data, 'records'),
+        merge: (local, data) => mergeAnalystReviewStateStores(local.analystReviewState, data),
+    },
+    {
+        id: 'settings', label: 'Workspace settings', schema: compatibilitySchema(WORKSPACE_SETTINGS_COMPATIBILITY),
+        version: WORKSPACE_SETTINGS_COMPATIBILITY.currentVersion,
+        supportedVersions: WORKSPACE_SETTINGS_COMPATIBILITY.supportedVersions,
         count: () => 1,
         merge: null,
     },
@@ -257,6 +265,7 @@ function normalizedInput(input) {
         websiteSnapshots: Array.isArray(value.websiteSnapshots) ? value.websiteSnapshots : [],
         investigationTemplates: Array.isArray(value.investigationTemplates) ? value.investigationTemplates : [],
         bulkReview: record(value.bulkReview) || {},
+        analystReviewState: record(value.analystReviewState) || emptyAnalystReviewStateStore(),
         settings: record(value.settings) || {},
     };
 }
@@ -270,7 +279,9 @@ function ensureArchiveBudget(value) {
 }
 /** Build one deterministic, unencrypted archive from normalized local stores. */
 export async function buildWorkspaceArchive(input, options = {}) {
-    const now = timestamp(options.generatedAt) || new Date().toISOString();
+    const now = timestamp(options.generatedAt ?? new Date().toISOString());
+    if (!now)
+        throw new Error('Workspace archive generation time must use an explicit timezone.');
     const source = normalizedInput(input);
     const sections = workspaceArchiveSections(source, now);
     const manifestSections = [];
@@ -327,23 +338,35 @@ function manifestEntry(raw) {
 }
 /** Validate structure, section byte counts, and checksums without applying data. */
 export async function readWorkspaceArchive(raw, options = {}) {
+    assertWorkspaceInputGraph(raw, 'Workspace archive');
     const value = record(raw);
     if (!value || value.schema !== WORKSPACE_ARCHIVE_SCHEMA) {
         throw new Error('This file is not a WHOISleuth workspace archive.');
     }
     if (!isSupportedWorkspaceArchiveVersion(value.version)) {
+        if (typeof value.version === 'number' && Number.isSafeInteger(value.version) && value.version < WORKSPACE_ARCHIVE_VERSION) {
+            throw new Error(`Workspace archive schema ${value.version} is retired. Export it as schema ${WORKSPACE_ARCHIVE_VERSION} with the last broad-reader release before importing; no data was changed.`);
+        }
         if (typeof value.version === 'number' && Number.isSafeInteger(value.version) && value.version > WORKSPACE_ARCHIVE_VERSION) {
-            throw new Error(`This workspace archive uses newer schema ${value.version}. Update the app before importing it.`);
+            throw new Error(`Workspace archive schema ${value.version} is newer than the supported schema ${WORKSPACE_ARCHIVE_VERSION}; no data was changed.`);
         }
-        throw new Error(`Expected workspace archive schema 1, 2, 3, 4, or ${WORKSPACE_ARCHIVE_VERSION}.`);
+        throw new Error(`Expected a well-formed workspace archive using schema ${WORKSPACE_ARCHIVE_VERSION}; no data was changed.`);
     }
     const sourceVersion = value.version;
+    const expectedSectionIds = sourceVersion === PUBLIC_WORKSPACE_ARCHIVE_VERSION
+        ? PUBLIC_WORKSPACE_ARCHIVE_SECTION_IDS
+        : WORKSPACE_ARCHIVE_SECTION_IDS;
+    const generatedAt = timestamp(value.generatedAt);
+    if (!generatedAt)
+        throw new Error('The workspace archive generation time is invalid.');
     const { bytes } = ensureArchiveBudget(value);
+    assertExactKeys(value, WORKSPACE_ARCHIVE_ROOT_KEYS, `version ${sourceVersion} envelope`);
     const manifest = record(value.manifest);
     const sectionValues = record(value.sections);
     if (!manifest || !sectionValues || !Array.isArray(manifest.sections)) {
         throw new Error('The workspace archive manifest is missing or malformed.');
     }
+    assertExactKeys(manifest, WORKSPACE_ARCHIVE_MANIFEST_KEYS, 'manifest');
     if (manifest.sections.length > MAX_WORKSPACE_ARCHIVE_SECTIONS) {
         throw new Error(`Workspace archives are limited to ${MAX_WORKSPACE_ARCHIVE_SECTIONS} sections.`);
     }
@@ -351,6 +374,10 @@ export async function readWorkspaceArchive(raw, options = {}) {
     const sections = [];
     let totalRecords = 0;
     for (const rawEntry of manifest.sections) {
+        const rawEntryRecord = record(rawEntry);
+        if (!rawEntryRecord)
+            throw new Error('The workspace archive manifest contains a malformed section entry.');
+        assertExactKeys(rawEntryRecord, WORKSPACE_ARCHIVE_MANIFEST_ENTRY_KEYS, 'manifest section entry');
         const entry = manifestEntry(rawEntry);
         if (!entry || seen.has(entry.id) || !Object.prototype.hasOwnProperty.call(sectionValues, entry.id)) {
             throw new Error('The workspace archive manifest contains an invalid, duplicate, or missing section.');
@@ -363,6 +390,21 @@ export async function readWorkspaceArchive(raw, options = {}) {
         if (await checksum(data, options.cryptoProvider) !== entry.checksum) {
             throw new Error(`${entry.id} failed its archive checksum check.`);
         }
+        const embedded = record(data);
+        const embeddedVersion = embedded?.version;
+        const embeddedSchema = embedded && Object.prototype.hasOwnProperty.call(embedded, 'schema')
+            ? embedded.schema
+            : null;
+        if (!embedded
+            || typeof embeddedVersion !== 'number'
+            || !Number.isSafeInteger(embeddedVersion)
+            || embeddedVersion < 1
+            || embeddedVersion > 1000
+            || (embeddedSchema !== null && typeof embeddedSchema !== 'string')
+            || embeddedVersion !== entry.version
+            || embeddedSchema !== entry.schema) {
+            throw new Error(`${entry.id} section contract does not match its archive manifest.`);
+        }
         const definition = DEFINITION_BY_ID.get(entry.id);
         let status = 'ready';
         let reason = '';
@@ -370,11 +412,13 @@ export async function readWorkspaceArchive(raw, options = {}) {
             status = 'unsupported';
             reason = 'This app does not recognise the archive section.';
         }
-        else if (entry.version !== definition.version || entry.schema !== definition.schema) {
+        else if (!(definition.supportedVersions ?? [definition.version]).includes(entry.version) || entry.schema !== definition.schema) {
             status = 'unsupported';
-            reason = entry.version > definition.version
-                ? `This section uses newer schema ${entry.version}.`
-                : 'This section uses an unsupported schema contract.';
+            reason = entry.schema !== definition.schema
+                ? 'This section uses an unsupported schema contract.'
+                : entry.version > definition.version
+                    ? `This section uses newer schema ${entry.version}.`
+                    : `This section uses retired schema ${entry.version}. Export it with the last broad-reader release before importing; no data was changed.`;
         }
         else if (definition.count(data) !== entry.recordCount) {
             throw new Error(`${entry.id} does not match its manifest record count.`);
@@ -388,12 +432,30 @@ export async function readWorkspaceArchive(raw, options = {}) {
     if (manifest.sectionCount !== sections.length || manifest.totalRecords !== totalRecords) {
         throw new Error('The workspace archive manifest totals do not match its sections.');
     }
+    if (seen.size !== expectedSectionIds.length || expectedSectionIds.some((id) => !seen.has(id))) {
+        throw new Error(`Workspace archive schema ${sourceVersion} does not contain its exact required section set.`);
+    }
+    if (sourceVersion === PUBLIC_WORKSPACE_ARCHIVE_VERSION) {
+        const data = emptyAnalystReviewStateStore();
+        sections.push({
+            id: 'analystReviewState',
+            label: 'Analyst Review Item lifecycle',
+            schema: compatibilitySchema(ANALYST_REVIEW_STATE_COMPATIBILITY),
+            version: ANALYST_REVIEW_STATE_COMPATIBILITY.currentVersion,
+            recordCount: 0,
+            bytes: byteLength(serialize(data)),
+            checksum: await checksum(data, options.cryptoProvider),
+            status: 'ready',
+            reason: `Workspace schema ${PUBLIC_WORKSPACE_ARCHIVE_VERSION} did not contain Review Item lifecycle state. Import supplies an empty section and invents no analyst decisions.`,
+            data,
+        });
+    }
     sections.sort(canonicalSectionOrder);
     return {
         schema: WORKSPACE_ARCHIVE_SCHEMA,
         version: WORKSPACE_ARCHIVE_VERSION,
         sourceVersion,
-        generatedAt: timestamp(value.generatedAt),
+        generatedAt,
         bytes,
         sections,
         limitations: Array.isArray(value.limitations)
@@ -403,14 +465,31 @@ export async function readWorkspaceArchive(raw, options = {}) {
 }
 function settingsPreview(data, local, mergedProfiles) {
     const value = record(data) || {};
-    const activeProfileId = normalizeBrandProfileId(value.activeProfileId) || '';
+    const rawActiveProfileId = value.activeProfileId;
+    const intentionalClear = rawActiveProfileId === '';
+    const normalizedActiveProfileId = normalizeBrandProfileId(rawActiveProfileId);
+    const validActiveProfileId = typeof rawActiveProfileId === 'string'
+        && rawActiveProfileId.length > 0
+        && normalizedActiveProfileId === rawActiveProfileId;
     const theme = normalizeTheme(value.theme);
+    const retainedActiveProfileId = normalizeBrandProfileId(local.settings?.activeProfileId) || '';
+    let activeProfileId = retainedActiveProfileId;
     let skipped = 0;
-    if (activeProfileId && !mergedProfiles.some((profile) => profile?.id === activeProfileId))
-        skipped++;
+    let reason = '';
+    if (!intentionalClear && !validActiveProfileId) {
+        skipped = 1;
+        reason = 'The imported active Brand Profile preference is missing or malformed. Existing active-profile context is preserved.';
+    }
+    else if (validActiveProfileId && !mergedProfiles.some((profile) => profile?.id === normalizedActiveProfileId)) {
+        skipped = 1;
+        reason = 'The imported active Brand Profile preference will be skipped because its identifier is not available in the selected Profile data or the current browser. Existing active-profile context is preserved.';
+    }
+    else {
+        activeProfileId = intentionalClear ? '' : normalizedActiveProfileId ?? retainedActiveProfileId;
+    }
     const updated = Number(theme !== normalizeTheme(local.settings?.theme)
-        || (Boolean(activeProfileId) && activeProfileId !== local.settings?.activeProfileId && skipped === 0));
-    return { added: 0, updated, skipped, settings: { activeProfileId: skipped ? '' : activeProfileId, theme } };
+        || (skipped === 0 && activeProfileId !== retainedActiveProfileId));
+    return { added: 0, updated, skipped, reason, settings: { activeProfileId, theme } };
 }
 /** Preview section-specific non-destructive merge outcomes without writing. */
 export async function previewWorkspaceArchive(raw, localInput, options = {}) {
@@ -418,6 +497,9 @@ export async function previewWorkspaceArchive(raw, localInput, options = {}) {
     const local = normalizedInput(localInput);
     const results = [];
     let mergedProfiles = local.brandProfiles;
+    const selectedIds = options.selectedSectionIds
+        ? new Set(options.selectedSectionIds.slice(0, MAX_WORKSPACE_ARCHIVE_SECTIONS))
+        : null;
     for (const section of archive.sections) {
         if (section.status !== 'ready') {
             results.push({ ...section, added: 0, updated: 0, skipped: section.recordCount, selected: false });
@@ -432,17 +514,21 @@ export async function previewWorkspaceArchive(raw, localInput, options = {}) {
                 : definition.merge
                     ? definition.merge(local, section.data, archive.generatedAt)
                     : { added: 0, updated: 0, skipped: section.recordCount };
-            if (definition.id === 'brandProfiles' && result.profiles)
+            const selected = selectedIds ? selectedIds.has(section.id) : true;
+            if (definition.id === 'brandProfiles' && selected && result.profiles)
                 mergedProfiles = result.profiles;
             results.push({
                 ...section,
                 status: 'ready',
-                reason: '',
+                reason: definition.id === 'settings' && selected && (result.skipped ?? 0) > 0
+                    ? result.reason ?? 'The imported workspace preference was skipped. Existing browser-local context is preserved.'
+                    : section.reason,
                 added: result.added ?? 0,
                 updated: result.updated ?? 0,
                 skipped: result.skipped ?? 0,
                 pruned: result.pruned ?? 0,
-                selected: true,
+                brandProfileReferencesOmitted: result.brandProfileReferencesOmitted ?? 0,
+                selected,
                 normalizedSettings: result.settings || null,
             });
         }
@@ -461,6 +547,31 @@ export async function previewWorkspaceArchive(raw, localInput, options = {}) {
             });
         }
     }
+    const profileCollision = results.find((section) => section.id === 'brandProfiles'
+        && section.status === 'blocked'
+        && /reuses one exact identifier for different normalised profile names/iu.test(section.reason));
+    if (profileCollision) {
+        for (const dependentId of ['cases', 'settings']) {
+            const dependentIndex = results.findIndex((section) => section.id === dependentId && section.status === 'ready');
+            const dependentSection = results[dependentIndex];
+            if (dependentIndex < 0 || !dependentSection)
+                continue;
+            results[dependentIndex] = {
+                ...dependentSection,
+                status: 'blocked',
+                reason: dependentId === 'cases'
+                    ? 'Cases were not selected because a Brand Profile identifier collision must be resolved before their opaque references can be imported safely.'
+                    : 'Workspace settings were not selected because an active Brand Profile preference could otherwise bind to a different local profile that reuses the same identifier.',
+                added: 0,
+                updated: 0,
+                skipped: dependentSection.recordCount,
+                pruned: 0,
+                brandProfileReferencesOmitted: 0,
+                selected: false,
+                normalizedSettings: dependentId === 'settings' ? null : dependentSection.normalizedSettings ?? null,
+            };
+        }
+    }
     return {
         ...archive,
         sections: results,