@straiffi/archon 1.5.0 → 1.6.0

package/dist/server/lib/projectMemoryTransfer.js

@@ -1,15 +1,29 @@
 import { randomUUID } from 'crypto';
 import db from '../db.js';
-const PROJECT_MEMORY_ARCHIVE_EXPORT_VERSION = 3;
-const PROJECT_MEMORY_ARCHIVE_SUPPORTED_VERSIONS = [1, 2, 3];
+import { containsReservedProjectMemoryControlMarker, PROJECT_MEMORY_LIMITS } from './projectMemoryLimits.js';
+const PROJECT_MEMORY_ARCHIVE_EXPORT_VERSION = 7;
+const PROJECT_MEMORY_ARCHIVE_SUPPORTED_VERSIONS = [1, 2, 3, 4, 5, 6, 7];
 const PROJECT_MEMORY_STAGES = ['plan', 'build', 'review', 'follow_up', 'plan_follow_up', 'chat'];
 const PROJECT_CONVENTION_PRIORITIES = ['critical', 'normal', 'low'];
 const PROJECT_CONVENTION_INJECTION_MODES = ['always', 'relevant'];
 const PROJECT_CONVENTION_STATUSES = ['active', 'archived'];
 const PROJECT_DECISION_STATUSES = ['accepted', 'archived', 'superseded'];
 const PROJECT_CONTEXT_SCAN_STATUSES = ['pending', 'running', 'done', 'error'];
+const IMPORTED_ACTIVE_SCAN_ERROR = 'Imported scan was active when archived and cannot be resumed.';
 const PROJECT_CONTEXT_ARTIFACT_KINDS = ['architecture', 'key_areas', 'conventions', 'risks'];
 const TOOL_NAMES = ['claude', 'opencode'];
+const PROJECT_CONTEXT_SCAN_ORIGINS = ['local_scan', 'archive_import'];
+const PROJECT_CONTEXT_SCAN_SKIP_REASONS = [
+    'hard_excluded',
+    'user_excluded',
+    'not_included',
+    'symlink',
+    'binary',
+    'unreadable',
+    'file_size_limit',
+    'file_count_limit',
+    'directory_limit',
+];
 const isRecord = (value) => {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 };
@@ -26,25 +40,25 @@ const normalizeOptionalString = (value, fieldName) => {
         return { value: null };
     }
     if (typeof value !== 'string') {
-        return { error: `${fieldName} must be a string or null` };
+        return { error: `${fieldName} must be a string or null`, kind: 'malformed' };
     }
     const trimmed = value.trim();
     return { value: trimmed === '' ? null : trimmed };
 };
 const validateRequiredString = (value, fieldName) => {
     if (typeof value !== 'string' || value.trim() === '') {
-        return { error: `${fieldName} must be a non-empty string` };
+        return { error: `${fieldName} must be a non-empty string`, kind: 'malformed' };
     }
     return { value: value.trim() };
 };
 const normalizeStringArray = (value, fieldName) => {
     if (!Array.isArray(value)) {
-        return { error: `${fieldName} must be an array of strings` };
+        return { error: `${fieldName} must be an array of strings`, kind: 'malformed' };
     }
     const normalized = [];
     for (const entry of value) {
         if (typeof entry !== 'string' || entry.trim() === '') {
-            return { error: `${fieldName} must be an array of strings` };
+            return { error: `${fieldName} must be an array of strings`, kind: 'malformed' };
         }
         const trimmed = entry.trim();
         if (!normalized.includes(trimmed)) {
@@ -55,12 +69,12 @@ const normalizeStringArray = (value, fieldName) => {
 };
 const validateStages = (value) => {
     if (!Array.isArray(value)) {
-        return { error: 'memory.conventions[].stages must be an array of valid project memory stages' };
+        return { error: 'memory.conventions[].stages must be an array of valid project memory stages', kind: 'malformed' };
     }
     const normalized = [];
     for (const stage of value) {
         if (!PROJECT_MEMORY_STAGES.includes(stage)) {
-            return { error: 'memory.conventions[].stages must be an array of valid project memory stages' };
+            return { error: 'memory.conventions[].stages must be an array of valid project memory stages', kind: 'malformed' };
         }
         if (!normalized.includes(stage)) {
             normalized.push(stage);
@@ -70,10 +84,64 @@ const validateStages = (value) => {
 };
 const validateEnum = (value, values, fieldName) => {
     if (!values.includes(value)) {
-        return { error: `${fieldName} must be one of ${values.join(', ')}` };
+        return { error: `${fieldName} must be one of ${values.join(', ')}`, kind: 'malformed' };
     }
     return { value: value };
 };
+const validateStringLimit = (result, fieldName, limit) => {
+    if ('error' in result) {
+        return result;
+    }
+    if (result.value !== null && result.value.length > limit) {
+        return { error: `${fieldName} must not exceed ${limit} characters`, kind: 'limit', code: 'field_too_large', field: fieldName, limit };
+    }
+    if (result.value !== null && containsReservedProjectMemoryControlMarker(result.value)) {
+        return { error: `${fieldName} must not contain a reserved control marker`, kind: 'malformed', code: 'reserved_control_marker', field: fieldName };
+    }
+    return result;
+};
+const validateArrayLimit = (value, fieldName, limit) => {
+    if (value.length > limit) {
+        return { error: `${fieldName} must not contain more than ${limit} items`, kind: 'limit', code: 'field_too_large', field: fieldName, limit };
+    }
+    return { value };
+};
+const validateImplications = (value, fieldName) => {
+    const implications = normalizeStringArray(value, fieldName);
+    if ('error' in implications) {
+        return implications;
+    }
+    const count = validateArrayLimit(implications.value, fieldName, PROJECT_MEMORY_LIMITS.implications);
+    if ('error' in count) {
+        return count;
+    }
+    for (const implication of count.value) {
+        if (implication.length > PROJECT_MEMORY_LIMITS.implication) {
+            return { error: `${fieldName}[] must not exceed ${PROJECT_MEMORY_LIMITS.implication} characters`, kind: 'limit', code: 'field_too_large', field: fieldName, limit: PROJECT_MEMORY_LIMITS.implication };
+        }
+        if (containsReservedProjectMemoryControlMarker(implication)) {
+            return { error: `${fieldName}[] must not contain a reserved control marker`, kind: 'malformed', code: 'reserved_control_marker', field: fieldName };
+        }
+    }
+    return count;
+};
+const validateApplicabilityStrings = (value, fieldName) => {
+    const strings = normalizeStringArray(value ?? [], fieldName);
+    if ('error' in strings) {
+        return strings;
+    }
+    const count = validateArrayLimit(strings.value, fieldName, PROJECT_MEMORY_LIMITS.applicabilityItems);
+    if ('error' in count) {
+        return count;
+    }
+    for (const entry of count.value) {
+        const validated = validateStringLimit({ value: entry }, fieldName, PROJECT_MEMORY_LIMITS.applicabilityItem);
+        if ('error' in validated) {
+            return validated;
+        }
+    }
+    return count;
+};
 const validateNullableEnum = (value, values, fieldName) => {
     if (value == null) {
         return { value: null };
@@ -101,6 +169,41 @@ const parseStringArrayColumn = (value) => {
         .map(entry => entry.trim())
         .filter(Boolean);
 };
+const createManualArchiveOrigin = (createdAt) => ({
+    type: 'manual',
+    suggestion_id: null,
+    source_stage: null,
+    source_type: null,
+    source_label: null,
+    ticket_id: null,
+    chat_session_id: null,
+    spec_session_id: null,
+    suggested_at: null,
+    accepted_at: createdAt,
+});
+const parseArchiveOrigin = (value, createdAt) => {
+    const parsed = parseJsonColumn(value);
+    if (!isRecord(parsed) || parsed.type !== 'agent_suggestion') {
+        return createManualArchiveOrigin(createdAt);
+    }
+    const sourceType = parsed.source_type === 'ticket' || parsed.source_type === 'chat_session' || parsed.source_type === 'spec_session'
+        ? parsed.source_type
+        : null;
+    return {
+        type: 'agent_suggestion',
+        suggestion_id: typeof parsed.suggestion_id === 'string' ? parsed.suggestion_id : null,
+        source_stage: PROJECT_MEMORY_STAGES.includes(parsed.source_stage)
+            ? parsed.source_stage
+            : null,
+        source_type: sourceType,
+        source_label: typeof parsed.source_label === 'string' ? parsed.source_label : null,
+        ticket_id: typeof parsed.ticket_id === 'string' ? parsed.ticket_id : null,
+        chat_session_id: typeof parsed.chat_session_id === 'string' ? parsed.chat_session_id : null,
+        spec_session_id: typeof parsed.spec_session_id === 'string' ? parsed.spec_session_id : null,
+        suggested_at: typeof parsed.suggested_at === 'string' ? parsed.suggested_at : null,
+        accepted_at: typeof parsed.accepted_at === 'string' ? parsed.accepted_at : createdAt,
+    };
+};
 const serializeConvention = (row) => {
     return {
         title: row.title,
@@ -108,6 +211,8 @@ const serializeConvention = (row) => {
         instruction: row.instruction,
         rationale: row.rationale,
         stages: parseStringArrayColumn(row.stages_json),
+        path_globs: parseStringArrayColumn(row.path_globs_json),
+        component_tags: parseStringArrayColumn(row.component_tags_json),
         priority: row.priority,
         injection_mode: PROJECT_CONVENTION_INJECTION_MODES.includes(row.injection_mode)
             ? row.injection_mode
@@ -124,22 +229,31 @@ const serializeDecision = (row) => {
         decision: row.decision,
         rationale: row.rationale,
         implications: parseStringArrayColumn(row.implications_json),
+        stages: parseStringArrayColumn(row.stages_json),
+        path_globs: parseStringArrayColumn(row.path_globs_json),
+        component_tags: parseStringArrayColumn(row.component_tags_json),
         status: row.status,
         created_at: row.created_at,
         updated_at: row.updated_at,
     };
 };
 const serializeMemoryItemFromConvention = (row) => {
+    const origin = parseArchiveOrigin(row.origin_json, row.created_at);
     return {
+        archive_id: row.id,
+        superseded_by_archive_id: null,
         kind: 'convention',
         state: row.status,
-        source: 'manual',
+        source: origin.type === 'agent_suggestion' ? 'agent' : 'manual',
+        origin,
         title: row.title,
         scope: row.scope,
         content: row.instruction,
         rationale: row.rationale,
         implications: [],
         stages: parseStringArrayColumn(row.stages_json),
+        path_globs: parseStringArrayColumn(row.path_globs_json),
+        component_tags: parseStringArrayColumn(row.component_tags_json),
         priority: row.priority,
         injection_mode: PROJECT_CONVENTION_INJECTION_MODES.includes(row.injection_mode)
             ? row.injection_mode
@@ -149,16 +263,22 @@ const serializeMemoryItemFromConvention = (row) => {
     };
 };
 const serializeMemoryItemFromDecision = (row) => {
+    const origin = parseArchiveOrigin(row.origin_json, row.created_at);
     return {
+        archive_id: row.id,
+        superseded_by_archive_id: row.superseded_by_decision_id,
         kind: 'decision',
         state: row.status === 'accepted' ? 'active' : row.status,
-        source: 'manual',
+        source: origin.type === 'agent_suggestion' ? 'agent' : 'manual',
+        origin,
         title: row.title,
         scope: row.scope,
         content: row.decision,
         rationale: row.rationale,
         implications: parseStringArrayColumn(row.implications_json),
-        stages: [],
+        stages: parseStringArrayColumn(row.stages_json),
+        path_globs: parseStringArrayColumn(row.path_globs_json),
+        component_tags: parseStringArrayColumn(row.component_tags_json),
         priority: null,
         injection_mode: null,
         created_at: row.created_at,
@@ -181,6 +301,8 @@ const fingerprintConvention = (item) => {
         normalizeString(item.instruction),
         normalizeString(item.rationale),
         [...item.stages].sort(),
+        [...(item.path_globs ?? [])].sort(),
+        [...(item.component_tags ?? [])].sort(),
         item.priority,
         item.injection_mode,
         item.status,
@@ -193,10 +315,26 @@ const fingerprintDecision = (item) => {
         normalizeString(item.decision),
         normalizeString(item.rationale),
         item.implications.map(entry => normalizeString(entry)),
+        [...(item.stages ?? [])].sort(),
+        [...(item.path_globs ?? [])].sort(),
+        [...(item.component_tags ?? [])].sort(),
         item.status,
     ]);
 };
 const fingerprintScan = (item) => {
+    const manifest = item.manifest
+        ? {
+            sampled_paths: [...item.manifest.sampled_paths].sort(),
+            skipped_counts: Object.fromEntries(Object.entries(item.manifest.skipped_counts).sort(([left], [right]) => left.localeCompare(right))),
+            include_globs: [...item.manifest.include_globs].sort(),
+            exclude_globs: [...item.manifest.exclude_globs].sort(),
+            hard_exclusions: [...item.manifest.hard_exclusions].sort(),
+            repository_characters_sent: item.manifest.repository_characters_sent,
+            redaction_count: item.manifest.redaction_count,
+            truncated_output_fields: [...item.manifest.truncated_output_fields].sort(),
+            repository_changed_during_scan: item.manifest.repository_changed_during_scan,
+        }
+        : null;
     return JSON.stringify([
         item.status,
         normalizeString(item.repo_head),
@@ -206,6 +344,12 @@ const fingerprintScan = (item) => {
         normalizeString(item.scanner_variant),
         normalizeString(item.summary_markdown),
         normalizeString(item.error),
+        item.origin ?? 'local_scan',
+        normalizeString(item.scanner_provider),
+        item.scanned_at ?? null,
+        item.completed_at ?? null,
+        item.working_tree_dirty ?? null,
+        manifest,
     ]);
 };
 const fingerprintArtifact = (item) => {
@@ -224,21 +368,21 @@ const sanitizeJsonValue = (value) => {
 };
 const validateArchiveConvention = (value) => {
     if (!isRecord(value)) {
-        return { error: 'memory.conventions[] must be an object' };
+        return { error: 'memory.conventions[] must be an object', kind: 'malformed' };
     }
-    const title = validateRequiredString(value.title, 'memory.conventions[].title');
+    const title = validateStringLimit(validateRequiredString(value.title, 'memory.conventions[].title'), 'memory.conventions[].title', PROJECT_MEMORY_LIMITS.title);
     if ('error' in title) {
         return title;
     }
-    const scope = normalizeOptionalString(value.scope, 'memory.conventions[].scope');
+    const scope = validateStringLimit(normalizeOptionalString(value.scope, 'memory.conventions[].scope'), 'memory.conventions[].scope', PROJECT_MEMORY_LIMITS.scope);
     if ('error' in scope) {
         return scope;
     }
-    const instruction = validateRequiredString(value.instruction, 'memory.conventions[].instruction');
+    const instruction = validateStringLimit(validateRequiredString(value.instruction, 'memory.conventions[].instruction'), 'memory.conventions[].instruction', PROJECT_MEMORY_LIMITS.content);
     if ('error' in instruction) {
         return instruction;
     }
-    const rationale = normalizeOptionalString(value.rationale, 'memory.conventions[].rationale');
+    const rationale = validateStringLimit(normalizeOptionalString(value.rationale, 'memory.conventions[].rationale'), 'memory.conventions[].rationale', PROJECT_MEMORY_LIMITS.rationale);
     if ('error' in rationale) {
         return rationale;
     }
@@ -246,6 +390,14 @@ const validateArchiveConvention = (value) => {
     if ('error' in stages) {
         return stages;
     }
+    const pathGlobs = validateApplicabilityStrings(value.path_globs, 'memory.conventions[].path_globs');
+    if ('error' in pathGlobs) {
+        return pathGlobs;
+    }
+    const componentTags = validateApplicabilityStrings(value.component_tags, 'memory.conventions[].component_tags');
+    if ('error' in componentTags) {
+        return componentTags;
+    }
     const priority = validateEnum(value.priority, PROJECT_CONVENTION_PRIORITIES, 'memory.conventions[].priority');
     if ('error' in priority) {
         return priority;
@@ -275,6 +427,8 @@ const validateArchiveConvention = (value) => {
             instruction: instruction.value,
             rationale: rationale.value,
             stages: stages.value,
+            path_globs: pathGlobs.value,
+            component_tags: componentTags.value,
             priority: priority.value,
             injection_mode: injectionMode.value,
             status: status.value,
@@ -285,28 +439,40 @@ const validateArchiveConvention = (value) => {
 };
 const validateArchiveDecision = (value) => {
     if (!isRecord(value)) {
-        return { error: 'memory.decisions[] must be an object' };
+        return { error: 'memory.decisions[] must be an object', kind: 'malformed' };
     }
-    const title = validateRequiredString(value.title, 'memory.decisions[].title');
+    const title = validateStringLimit(validateRequiredString(value.title, 'memory.decisions[].title'), 'memory.decisions[].title', PROJECT_MEMORY_LIMITS.title);
     if ('error' in title) {
         return title;
     }
-    const scope = normalizeOptionalString(value.scope, 'memory.decisions[].scope');
+    const scope = validateStringLimit(normalizeOptionalString(value.scope, 'memory.decisions[].scope'), 'memory.decisions[].scope', PROJECT_MEMORY_LIMITS.scope);
     if ('error' in scope) {
         return scope;
     }
-    const decision = validateRequiredString(value.decision, 'memory.decisions[].decision');
+    const decision = validateStringLimit(validateRequiredString(value.decision, 'memory.decisions[].decision'), 'memory.decisions[].decision', PROJECT_MEMORY_LIMITS.content);
     if ('error' in decision) {
         return decision;
     }
-    const rationale = normalizeOptionalString(value.rationale, 'memory.decisions[].rationale');
+    const rationale = validateStringLimit(normalizeOptionalString(value.rationale, 'memory.decisions[].rationale'), 'memory.decisions[].rationale', PROJECT_MEMORY_LIMITS.rationale);
     if ('error' in rationale) {
         return rationale;
     }
-    const implications = normalizeStringArray(value.implications, 'memory.decisions[].implications');
+    const implications = validateImplications(value.implications, 'memory.decisions[].implications');
     if ('error' in implications) {
         return implications;
     }
+    const stages = validateStages(value.stages ?? []);
+    if ('error' in stages) {
+        return stages;
+    }
+    const pathGlobs = validateApplicabilityStrings(value.path_globs, 'memory.decisions[].path_globs');
+    if ('error' in pathGlobs) {
+        return pathGlobs;
+    }
+    const componentTags = validateApplicabilityStrings(value.component_tags, 'memory.decisions[].component_tags');
+    if ('error' in componentTags) {
+        return componentTags;
+    }
     const status = validateEnum(value.status, PROJECT_DECISION_STATUSES, 'memory.decisions[].status');
     if ('error' in status) {
         return status;
@@ -326,15 +492,74 @@ const validateArchiveDecision = (value) => {
             decision: decision.value,
             rationale: rationale.value,
             implications: implications.value,
+            stages: stages.value,
+            path_globs: pathGlobs.value,
+            component_tags: componentTags.value,
             status: status.value,
             created_at: createdAt.value,
             updated_at: updatedAt.value,
         },
     };
 };
-const validateArchiveItem = (value) => {
+const validateArchiveOrigin = (value) => {
+    if (!isRecord(value)) {
+        return { error: 'memory.items[].origin must be an object', kind: 'malformed' };
+    }
+    const type = validateEnum(value.type, ['manual', 'agent_suggestion'], 'memory.items[].origin.type');
+    if ('error' in type) {
+        return type;
+    }
+    if (type.value === 'manual') {
+        return { value: createManualArchiveOrigin(typeof value.accepted_at === 'string' ? value.accepted_at : new Date().toISOString()) };
+    }
+    const sourceType = validateEnum(value.source_type, ['ticket', 'chat_session', 'spec_session'], 'memory.items[].origin.source_type');
+    if ('error' in sourceType) {
+        return sourceType;
+    }
+    const sourceLabel = validateRequiredString(value.source_label, 'memory.items[].origin.source_label');
+    if ('error' in sourceLabel) {
+        return sourceLabel;
+    }
+    const sourceStage = validateEnum(value.source_stage, PROJECT_MEMORY_STAGES, 'memory.items[].origin.source_stage');
+    if ('error' in sourceStage) {
+        return sourceStage;
+    }
+    const suggestedAt = validateRequiredString(value.suggested_at, 'memory.items[].origin.suggested_at');
+    if ('error' in suggestedAt) {
+        return suggestedAt;
+    }
+    const acceptedAt = validateRequiredString(value.accepted_at, 'memory.items[].origin.accepted_at');
+    if ('error' in acceptedAt) {
+        return acceptedAt;
+    }
+    return {
+        value: {
+            type: 'agent_suggestion',
+            suggestion_id: typeof value.suggestion_id === 'string' ? value.suggestion_id : null,
+            source_stage: sourceStage.value,
+            source_type: sourceType.value,
+            source_label: sourceLabel.value,
+            ticket_id: typeof value.ticket_id === 'string' ? value.ticket_id : null,
+            chat_session_id: typeof value.chat_session_id === 'string' ? value.chat_session_id : null,
+            spec_session_id: typeof value.spec_session_id === 'string' ? value.spec_session_id : null,
+            suggested_at: suggestedAt.value,
+            accepted_at: acceptedAt.value,
+        },
+    };
+};
+const validateArchiveItem = (value, { requiresOrigin = false, requiresRelationships = false } = {}) => {
     if (!isRecord(value)) {
-        return { error: 'memory.items[] must be an object' };
+        return { error: 'memory.items[] must be an object', kind: 'malformed' };
+    }
+    const archiveId = requiresRelationships ? validateRequiredString(value.archive_id, 'memory.items[].archive_id') : { value: undefined };
+    if ('error' in archiveId) {
+        return archiveId;
+    }
+    const supersededByArchiveId = requiresRelationships
+        ? normalizeOptionalString(value.superseded_by_archive_id, 'memory.items[].superseded_by_archive_id')
+        : { value: undefined };
+    if ('error' in supersededByArchiveId) {
+        return supersededByArchiveId;
     }
     const kind = validateEnum(value.kind, ['decision', 'convention'], 'memory.items[].kind');
     if ('error' in kind) {
@@ -344,36 +569,56 @@ const validateArchiveItem = (value) => {
     if ('error' in state) {
         return state;
     }
-    const source = validateEnum(value.source, ['manual'], 'memory.items[].source');
+    const source = validateEnum(value.source, requiresOrigin ? ['manual', 'agent'] : ['manual'], 'memory.items[].source');
     if ('error' in source) {
         return source;
     }
+    const origin = requiresOrigin
+        ? validateArchiveOrigin(value.origin)
+        : { value: undefined };
+    if ('error' in origin) {
+        return origin;
+    }
+    if (source.value === 'agent' && origin.value?.type !== 'agent_suggestion') {
+        return { error: 'memory.items[].agent source requires an agent suggestion origin', kind: 'malformed' };
+    }
+    if (source.value === 'manual' && origin.value?.type === 'agent_suggestion') {
+        return { error: 'memory.items[].manual source cannot include an agent suggestion origin', kind: 'malformed' };
+    }
     if (kind.value === 'convention' && state.value === 'superseded') {
-        return { error: 'memory.items[] conventions cannot use the superseded state' };
+        return { error: 'memory.items[] conventions cannot use the superseded state', kind: 'malformed' };
     }
-    const title = validateRequiredString(value.title, 'memory.items[].title');
+    const title = validateStringLimit(validateRequiredString(value.title, 'memory.items[].title'), 'memory.items[].title', PROJECT_MEMORY_LIMITS.title);
     if ('error' in title) {
         return title;
     }
-    const scope = normalizeOptionalString(value.scope, 'memory.items[].scope');
+    const scope = validateStringLimit(normalizeOptionalString(value.scope, 'memory.items[].scope'), 'memory.items[].scope', PROJECT_MEMORY_LIMITS.scope);
     if ('error' in scope) {
         return scope;
     }
-    const content = validateRequiredString(value.content, 'memory.items[].content');
+    const content = validateStringLimit(validateRequiredString(value.content, 'memory.items[].content'), 'memory.items[].content', PROJECT_MEMORY_LIMITS.content);
     if ('error' in content) {
         return content;
     }
-    const rationale = normalizeOptionalString(value.rationale, 'memory.items[].rationale');
+    const rationale = validateStringLimit(normalizeOptionalString(value.rationale, 'memory.items[].rationale'), 'memory.items[].rationale', PROJECT_MEMORY_LIMITS.rationale);
     if ('error' in rationale) {
         return rationale;
     }
-    const implications = normalizeStringArray(value.implications ?? [], 'memory.items[].implications');
+    const implications = validateImplications(value.implications ?? [], 'memory.items[].implications');
     if ('error' in implications) {
         return implications;
     }
     const stages = validateStages(value.stages ?? []);
     if ('error' in stages) {
-        return { error: 'memory.items[].stages must be an array of valid project memory stages' };
+        return { error: 'memory.items[].stages must be an array of valid project memory stages', kind: 'malformed' };
+    }
+    const pathGlobs = validateApplicabilityStrings(value.path_globs, 'memory.items[].path_globs');
+    if ('error' in pathGlobs) {
+        return pathGlobs;
+    }
+    const componentTags = validateApplicabilityStrings(value.component_tags, 'memory.items[].component_tags');
+    if ('error' in componentTags) {
+        return componentTags;
     }
     const priority = value.priority == null
         ? { value: null }
@@ -387,20 +632,17 @@ const validateArchiveItem = (value) => {
     if ('error' in injectionMode) {
         return injectionMode;
     }
-    if (kind.value === 'decision' && stages.value.length > 0) {
-        return { error: 'memory.items[] decisions cannot include stages' };
-    }
     if (kind.value === 'decision' && priority.value !== null) {
-        return { error: 'memory.items[] decisions cannot include priority' };
+        return { error: 'memory.items[] decisions cannot include priority', kind: 'malformed' };
     }
     if (kind.value === 'decision' && injectionMode.value !== null) {
-        return { error: 'memory.items[] decisions cannot include injection_mode' };
+        return { error: 'memory.items[] decisions cannot include injection_mode', kind: 'malformed' };
     }
     if (kind.value === 'convention' && implications.value.length > 0) {
-        return { error: 'memory.items[] conventions cannot include implications' };
+        return { error: 'memory.items[] conventions cannot include implications', kind: 'malformed' };
     }
     if (kind.value === 'convention' && injectionMode.value === null) {
-        return { error: 'memory.items[] conventions must include injection_mode' };
+        return { error: 'memory.items[] conventions must include injection_mode', kind: 'malformed' };
     }
     const createdAt = validateRequiredString(value.created_at, 'memory.items[].created_at');
     if ('error' in createdAt) {
@@ -412,15 +654,20 @@ const validateArchiveItem = (value) => {
     }
     return {
         value: {
+            archive_id: archiveId.value,
+            superseded_by_archive_id: supersededByArchiveId.value,
             kind: kind.value,
             state: state.value,
             source: source.value,
+            origin: origin.value,
             title: title.value,
             scope: scope.value,
             content: content.value,
             rationale: rationale.value,
             implications: implications.value,
             stages: stages.value,
+            path_globs: pathGlobs.value,
+            component_tags: componentTags.value,
             priority: priority.value,
             injection_mode: injectionMode.value,
             created_at: createdAt.value,
@@ -428,19 +675,109 @@ const validateArchiveItem = (value) => {
         },
     };
 };
+const validateBoundedManifestStrings = (value, fieldName, countLimit, itemLimit = PROJECT_MEMORY_LIMITS.scanManifestPath) => {
+    const strings = normalizeStringArray(value, fieldName);
+    if ('error' in strings) {
+        return strings;
+    }
+    const count = validateArrayLimit(strings.value, fieldName, countLimit);
+    if ('error' in count) {
+        return count;
+    }
+    for (const entry of count.value) {
+        if (entry.length > itemLimit) {
+            return { error: `${fieldName}[] must not exceed ${itemLimit} characters`, kind: 'limit', code: 'field_too_large', field: fieldName, limit: itemLimit };
+        }
+    }
+    return count;
+};
+const validateNonNegativeInteger = (value, fieldName) => {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+        return { error: `${fieldName} must be a non-negative integer`, kind: 'malformed' };
+    }
+    return { value };
+};
+const validateArchiveManifest = (value) => {
+    if (value == null) {
+        return { value: null };
+    }
+    if (!isRecord(value)) {
+        return { error: 'memory.scans[].manifest must be an object or null', kind: 'malformed' };
+    }
+    const sampledPaths = validateBoundedManifestStrings(value.sampled_paths, 'memory.scans[].manifest.sampled_paths', PROJECT_MEMORY_LIMITS.scanManifestPaths);
+    if ('error' in sampledPaths) {
+        return sampledPaths;
+    }
+    const includeGlobs = validateBoundedManifestStrings(value.include_globs, 'memory.scans[].manifest.include_globs', PROJECT_MEMORY_LIMITS.scanGlobs, PROJECT_MEMORY_LIMITS.scanGlob);
+    if ('error' in includeGlobs) {
+        return includeGlobs;
+    }
+    const excludeGlobs = validateBoundedManifestStrings(value.exclude_globs, 'memory.scans[].manifest.exclude_globs', PROJECT_MEMORY_LIMITS.scanGlobs, PROJECT_MEMORY_LIMITS.scanGlob);
+    if ('error' in excludeGlobs) {
+        return excludeGlobs;
+    }
+    const hardExclusions = validateBoundedManifestStrings(value.hard_exclusions, 'memory.scans[].manifest.hard_exclusions', PROJECT_MEMORY_LIMITS.scanManifestHardExclusions, PROJECT_MEMORY_LIMITS.scanGlob);
+    if ('error' in hardExclusions) {
+        return hardExclusions;
+    }
+    const truncatedOutputFields = validateBoundedManifestStrings(value.truncated_output_fields, 'memory.scans[].manifest.truncated_output_fields', PROJECT_MEMORY_LIMITS.scanManifestTruncatedFields);
+    if ('error' in truncatedOutputFields) {
+        return truncatedOutputFields;
+    }
+    if (!isRecord(value.skipped_counts)) {
+        return { error: 'memory.scans[].manifest.skipped_counts must be an object', kind: 'malformed' };
+    }
+    const skippedCounts = {};
+    for (const [reason, rawCount] of Object.entries(value.skipped_counts)) {
+        if (!PROJECT_CONTEXT_SCAN_SKIP_REASONS.includes(reason)) {
+            return { error: `memory.scans[].manifest.skipped_counts contains unsupported reason ${reason}`, kind: 'malformed' };
+        }
+        const count = validateNonNegativeInteger(rawCount, `memory.scans[].manifest.skipped_counts.${reason}`);
+        if ('error' in count) {
+            return count;
+        }
+        skippedCounts[reason] = count.value;
+    }
+    const repositoryCharactersSent = validateNonNegativeInteger(value.repository_characters_sent, 'memory.scans[].manifest.repository_characters_sent');
+    if ('error' in repositoryCharactersSent) {
+        return repositoryCharactersSent;
+    }
+    const redactionCount = validateNonNegativeInteger(value.redaction_count, 'memory.scans[].manifest.redaction_count');
+    if ('error' in redactionCount) {
+        return redactionCount;
+    }
+    if (typeof value.repository_changed_during_scan !== 'boolean') {
+        return { error: 'memory.scans[].manifest.repository_changed_during_scan must be a boolean', kind: 'malformed' };
+    }
+    const manifest = {
+        sampled_paths: sampledPaths.value,
+        skipped_counts: skippedCounts,
+        include_globs: includeGlobs.value,
+        exclude_globs: excludeGlobs.value,
+        hard_exclusions: hardExclusions.value,
+        repository_characters_sent: repositoryCharactersSent.value,
+        redaction_count: redactionCount.value,
+        truncated_output_fields: truncatedOutputFields.value,
+        repository_changed_during_scan: value.repository_changed_during_scan,
+    };
+    if (Buffer.byteLength(JSON.stringify(manifest), 'utf8') > PROJECT_MEMORY_LIMITS.scanManifestBytes) {
+        return { error: `memory.scans[].manifest must not exceed ${PROJECT_MEMORY_LIMITS.scanManifestBytes} bytes`, kind: 'limit', code: 'field_too_large', field: 'memory.scans[].manifest', limit: PROJECT_MEMORY_LIMITS.scanManifestBytes };
+    }
+    return { value: manifest };
+};
 const validateArchiveArtifact = (value) => {
     if (!isRecord(value)) {
-        return { error: 'memory.scans[].artifacts[] must be an object' };
+        return { error: 'memory.scans[].artifacts[] must be an object', kind: 'malformed' };
     }
     const kind = validateEnum(value.kind, PROJECT_CONTEXT_ARTIFACT_KINDS, 'memory.scans[].artifacts[].kind');
     if ('error' in kind) {
         return kind;
     }
-    const title = validateRequiredString(value.title, 'memory.scans[].artifacts[].title');
+    const title = validateStringLimit(validateRequiredString(value.title, 'memory.scans[].artifacts[].title'), 'memory.scans[].artifacts[].title', PROJECT_MEMORY_LIMITS.title);
     if ('error' in title) {
         return title;
     }
-    const markdown = normalizeOptionalString(value.content_markdown, 'memory.scans[].artifacts[].content_markdown');
+    const markdown = validateStringLimit(normalizeOptionalString(value.content_markdown, 'memory.scans[].artifacts[].content_markdown'), 'memory.scans[].artifacts[].content_markdown', PROJECT_MEMORY_LIMITS.scanSummary);
     if ('error' in markdown) {
         return markdown;
     }
@@ -448,19 +785,23 @@ const validateArchiveArtifact = (value) => {
     if ('error' in createdAt) {
         return createdAt;
     }
+    const contentJson = sanitizeJsonValue(value.content_json);
+    if (Buffer.byteLength(JSON.stringify(contentJson), 'utf8') > PROJECT_MEMORY_LIMITS.scanArtifactJsonBytes) {
+        return { error: `memory.scans[].artifacts[].content_json must not exceed ${PROJECT_MEMORY_LIMITS.scanArtifactJsonBytes} bytes`, kind: 'limit', code: 'field_too_large', field: 'memory.scans[].artifacts[].content_json', limit: PROJECT_MEMORY_LIMITS.scanArtifactJsonBytes };
+    }
     return {
         value: {
             kind: kind.value,
             title: title.value,
-            content_json: sanitizeJsonValue(value.content_json),
+            content_json: contentJson,
             content_markdown: markdown.value,
             created_at: createdAt.value,
         },
     };
 };
-const validateArchiveScan = (value) => {
+const validateArchiveScan = (value, requiresMetadata = false) => {
     if (!isRecord(value)) {
-        return { error: 'memory.scans[] must be an object' };
+        return { error: 'memory.scans[] must be an object', kind: 'malformed' };
     }
     const status = validateEnum(value.status, PROJECT_CONTEXT_SCAN_STATUSES, 'memory.scans[].status');
     if ('error' in status) {
@@ -486,11 +827,43 @@ const validateArchiveScan = (value) => {
     if ('error' in scannerVariant) {
         return scannerVariant;
     }
-    const summaryMarkdown = normalizeOptionalString(value.summary_markdown, 'memory.scans[].summary_markdown');
+    const metadataFields = ['scanner_provider', 'origin', 'scanned_at', 'completed_at', 'working_tree_dirty', 'manifest'];
+    if (requiresMetadata) {
+        const missingField = metadataFields.find(field => !Object.hasOwn(value, field));
+        if (missingField) {
+            return { error: `memory.scans[].${missingField} must be present`, kind: 'malformed' };
+        }
+    }
+    const scannerProvider = validateStringLimit(normalizeOptionalString(value.scanner_provider, 'memory.scans[].scanner_provider'), 'memory.scans[].scanner_provider', PROJECT_MEMORY_LIMITS.scanMetadata);
+    if ('error' in scannerProvider) {
+        return scannerProvider;
+    }
+    const origin = value.origin == null && !requiresMetadata
+        ? { value: undefined }
+        : validateEnum(value.origin, PROJECT_CONTEXT_SCAN_ORIGINS, 'memory.scans[].origin');
+    if ('error' in origin) {
+        return origin;
+    }
+    const scannedAt = normalizeOptionalString(value.scanned_at, 'memory.scans[].scanned_at');
+    if ('error' in scannedAt) {
+        return scannedAt;
+    }
+    const completedAt = normalizeOptionalString(value.completed_at, 'memory.scans[].completed_at');
+    if ('error' in completedAt) {
+        return completedAt;
+    }
+    if (value.working_tree_dirty != null && typeof value.working_tree_dirty !== 'boolean') {
+        return { error: 'memory.scans[].working_tree_dirty must be a boolean or null', kind: 'malformed' };
+    }
+    const manifest = validateArchiveManifest(value.manifest);
+    if ('error' in manifest) {
+        return manifest;
+    }
+    const summaryMarkdown = validateStringLimit(normalizeOptionalString(value.summary_markdown, 'memory.scans[].summary_markdown'), 'memory.scans[].summary_markdown', PROJECT_MEMORY_LIMITS.scanSummary);
     if ('error' in summaryMarkdown) {
         return summaryMarkdown;
     }
-    const errorValue = normalizeOptionalString(value.error, 'memory.scans[].error');
+    const errorValue = validateStringLimit(normalizeOptionalString(value.error, 'memory.scans[].error'), 'memory.scans[].error', PROJECT_MEMORY_LIMITS.scanError);
     if ('error' in errorValue) {
         return errorValue;
     }
@@ -503,7 +876,10 @@ const validateArchiveScan = (value) => {
         return updatedAt;
     }
     if (!Array.isArray(value.artifacts)) {
-        return { error: 'memory.scans[].artifacts must be an array' };
+        return { error: 'memory.scans[].artifacts must be an array', kind: 'malformed' };
+    }
+    if (value.artifacts.length > PROJECT_MEMORY_LIMITS.archiveArtifactsPerScan) {
+        return { error: `memory.scans[].artifacts must not contain more than ${PROJECT_MEMORY_LIMITS.archiveArtifactsPerScan} items`, kind: 'limit', code: 'field_too_large', field: 'memory.scans[].artifacts', limit: PROJECT_MEMORY_LIMITS.archiveArtifactsPerScan };
     }
     const artifacts = [];
     for (const artifactValue of value.artifacts) {
@@ -521,6 +897,12 @@ const validateArchiveScan = (value) => {
             scanner_tool: scannerTool.value,
             scanner_model: scannerModel.value,
             scanner_variant: scannerVariant.value,
+            scanner_provider: scannerProvider.value,
+            origin: origin.value,
+            scanned_at: scannedAt.value,
+            completed_at: completedAt.value,
+            working_tree_dirty: value.working_tree_dirty == null ? null : value.working_tree_dirty,
+            manifest: manifest.value,
             summary_markdown: summaryMarkdown.value,
             error: errorValue.value,
             created_at: createdAt.value,
@@ -529,19 +911,23 @@ const validateArchiveScan = (value) => {
         },
     };
 };
+const parseStoredScanManifest = (value) => {
+    const validation = validateArchiveManifest(parseJsonColumn(value));
+    return 'error' in validation ? null : validation.value;
+};
 export const validateProjectMemoryArchive = (value) => {
     if (!isRecord(value)) {
-        return { error: 'Project memory archive must be an object' };
+        return { error: 'Project memory archive must be an object', kind: 'malformed' };
     }
     if (!PROJECT_MEMORY_ARCHIVE_SUPPORTED_VERSIONS.includes(value.schema_version)) {
-        return { error: `Unsupported project memory archive schema version: ${String(value.schema_version ?? 'missing')}` };
+        return { error: `Unsupported project memory archive schema version: ${String(value.schema_version ?? 'missing')}`, kind: 'malformed' };
     }
     const exportedAt = validateRequiredString(value.exported_at, 'exported_at');
     if ('error' in exportedAt) {
         return exportedAt;
     }
     if (!isRecord(value.project)) {
-        return { error: 'project must be an object' };
+        return { error: 'project must be an object', kind: 'malformed' };
     }
     const sourceProjectId = validateRequiredString(value.project.source_project_id, 'project.source_project_id');
     if ('error' in sourceProjectId) {
@@ -552,55 +938,133 @@ export const validateProjectMemoryArchive = (value) => {
         return projectName;
     }
     if (typeof value.project.memory_enabled !== 'boolean') {
-        return { error: 'project.memory_enabled must be a boolean' };
+        return { error: 'project.memory_enabled must be a boolean', kind: 'malformed' };
     }
     if (!isRecord(value.memory)) {
-        return { error: 'memory must be an object' };
+        return { error: 'memory must be an object', kind: 'malformed' };
     }
     if (!Array.isArray(value.memory.scans)) {
-        return { error: 'memory.scans must be an array' };
+        return { error: 'memory.scans must be an array', kind: 'malformed' };
+    }
+    if (value.memory.scans.length > PROJECT_MEMORY_LIMITS.archiveScans) {
+        return { error: `memory.scans must not contain more than ${PROJECT_MEMORY_LIMITS.archiveScans} items`, kind: 'limit', code: 'field_too_large', field: 'memory.scans', limit: PROJECT_MEMORY_LIMITS.archiveScans };
+    }
+    const artifactCount = value.memory.scans.reduce((total, scan) => {
+        if (!isRecord(scan) || !Array.isArray(scan.artifacts)) {
+            return total;
+        }
+        return total + scan.artifacts.length;
+    }, 0);
+    if (artifactCount > PROJECT_MEMORY_LIMITS.archiveArtifactsTotal) {
+        return { error: `memory.scans[].artifacts must not contain more than ${PROJECT_MEMORY_LIMITS.archiveArtifactsTotal} aggregate items`, kind: 'limit', code: 'field_too_large', field: 'memory.scans[].artifacts', limit: PROJECT_MEMORY_LIMITS.archiveArtifactsTotal };
     }
     const scans = [];
     for (const scanValue of value.memory.scans) {
-        const scan = validateArchiveScan(scanValue);
+        const scan = validateArchiveScan(scanValue, value.schema_version === 7);
         if ('error' in scan) {
             return scan;
         }
         scans.push(scan.value);
     }
-    if (value.schema_version === 3) {
+    if (value.schema_version === 3 || value.schema_version === 4 || value.schema_version === 5 || value.schema_version === 6 || value.schema_version === 7) {
         if (!Array.isArray(value.memory.items)) {
-            return { error: 'memory.items must be an array' };
+            return { error: 'memory.items must be an array', kind: 'malformed' };
+        }
+        if (value.memory.items.length > PROJECT_MEMORY_LIMITS.archiveMemories) {
+            return { error: `memory.items must not contain more than ${PROJECT_MEMORY_LIMITS.archiveMemories} items`, kind: 'limit', code: 'field_too_large', field: 'memory.items', limit: PROJECT_MEMORY_LIMITS.archiveMemories };
         }
         const items = [];
         for (const itemValue of value.memory.items) {
-            const item = validateArchiveItem(itemValue);
+            const item = validateArchiveItem(itemValue, { requiresOrigin: value.schema_version >= 4, requiresRelationships: value.schema_version >= 6 });
             if ('error' in item) {
                 return item;
             }
             items.push(item.value);
         }
+        if (value.schema_version === 3) {
+            return {
+                value: {
+                    schema_version: 3,
+                    exported_at: exportedAt.value,
+                    project: {
+                        source_project_id: sourceProjectId.value,
+                        name: projectName.value,
+                        memory_enabled: value.project.memory_enabled,
+                    },
+                    memory: {
+                        items,
+                        scans,
+                    },
+                },
+            };
+        }
+        if (value.schema_version === 4) {
+            return {
+                value: {
+                    schema_version: 4,
+                    exported_at: exportedAt.value,
+                    project: {
+                        source_project_id: sourceProjectId.value,
+                        name: projectName.value,
+                        memory_enabled: value.project.memory_enabled,
+                    },
+                    memory: {
+                        items: items,
+                        scans,
+                    },
+                },
+            };
+        }
+        if (value.schema_version === 5) {
+            return {
+                value: {
+                    schema_version: 5,
+                    exported_at: exportedAt.value,
+                    project: {
+                        source_project_id: sourceProjectId.value,
+                        name: projectName.value,
+                        memory_enabled: value.project.memory_enabled,
+                    },
+                    memory: {
+                        items: items,
+                        scans,
+                    },
+                },
+            };
+        }
+        if (value.schema_version === 6) {
+            return {
+                value: {
+                    schema_version: 6,
+                    exported_at: exportedAt.value,
+                    project: { source_project_id: sourceProjectId.value, name: projectName.value, memory_enabled: value.project.memory_enabled },
+                    memory: {
+                        items: items,
+                        scans,
+                    },
+                },
+            };
+        }
         return {
             value: {
-                schema_version: 3,
+                schema_version: 7,
                 exported_at: exportedAt.value,
-                project: {
-                    source_project_id: sourceProjectId.value,
-                    name: projectName.value,
-                    memory_enabled: value.project.memory_enabled,
-                },
+                project: { source_project_id: sourceProjectId.value, name: projectName.value, memory_enabled: value.project.memory_enabled },
                 memory: {
-                    items,
-                    scans,
+                    items: items,
+                    scans: scans,
                 },
             },
         };
     }
     if (!Array.isArray(value.memory.conventions)) {
-        return { error: 'memory.conventions must be an array' };
+        return { error: 'memory.conventions must be an array', kind: 'malformed' };
     }
     if (!Array.isArray(value.memory.decisions)) {
-        return { error: 'memory.decisions must be an array' };
+        return { error: 'memory.decisions must be an array', kind: 'malformed' };
+    }
+    if (value.memory.conventions.length + value.memory.decisions.length > PROJECT_MEMORY_LIMITS.archiveMemories) {
+        return { error: `memory.conventions and memory.decisions must not contain more than ${PROJECT_MEMORY_LIMITS.archiveMemories} total items`, kind: 'limit', code: 'field_too_large', field: 'memory', limit: PROJECT_MEMORY_LIMITS.archiveMemories };
     }
     const conventions = [];
     for (const conventionValue of value.memory.conventions) {
@@ -684,6 +1148,12 @@ export const exportProjectMemoryArchive = (project) => {
                 scanner_tool: scanRow.scanner_tool,
                 scanner_model: scanRow.scanner_model,
                 scanner_variant: scanRow.scanner_variant,
+                scanner_provider: scanRow.scanner_provider,
+                origin: PROJECT_CONTEXT_SCAN_ORIGINS.includes(scanRow.origin) ? scanRow.origin : 'local_scan',
+                scanned_at: scanRow.scanned_at ?? scanRow.created_at,
+                completed_at: scanRow.completed_at,
+                working_tree_dirty: scanRow.working_tree_dirty == null ? null : Boolean(scanRow.working_tree_dirty),
+                manifest: parseStoredScanManifest(scanRow.manifest_json),
                 summary_markdown: scanRow.summary_markdown,
                 error: scanRow.error,
                 created_at: scanRow.created_at,
@@ -726,6 +1196,18 @@ const createConflict = (kind, title) => {
         reason: 'title_conflict',
     };
 };
+const getImportedArchiveOrigin = (origin, createdAt) => {
+    if (origin?.type !== 'agent_suggestion') {
+        return createManualArchiveOrigin(createdAt);
+    }
+    return {
+        ...origin,
+        suggestion_id: null,
+        ticket_id: null,
+        chat_session_id: null,
+        spec_session_id: null,
+    };
+};
 export const importProjectMemoryArchive = (projectId, archiveValue) => {
     const archive = validateProjectMemoryArchive(archiveValue);
     if ('error' in archive) {
@@ -745,8 +1227,17 @@ export const importProjectMemoryArchive = (projectId, archiveValue) => {
         conflicts: [],
     };
     const transaction = db.transaction((validatedArchive) => {
-        const archiveConventions = validatedArchive.schema_version === 3
+        const archiveItems = validatedArchive.schema_version === 3 || validatedArchive.schema_version === 4 || validatedArchive.schema_version === 5 || validatedArchive.schema_version === 6 || validatedArchive.schema_version === 7
             ? validatedArchive.memory.items
+            : [];
+        const legacyConventions = validatedArchive.schema_version === 1 || validatedArchive.schema_version === 2
+            ? validatedArchive.memory.conventions
+            : [];
+        const legacyDecisions = validatedArchive.schema_version === 1 || validatedArchive.schema_version === 2
+            ? validatedArchive.memory.decisions
+            : [];
+        const archiveConventions = archiveItems.length > 0 || validatedArchive.schema_version >= 3
+            ? archiveItems
                 .filter((item) => item.kind === 'convention')
                 .map(item => ({
                 title: item.title,
@@ -754,15 +1245,18 @@ export const importProjectMemoryArchive = (projectId, archiveValue) => {
                 instruction: item.content,
                 rationale: item.rationale,
                 stages: item.stages,
+                path_globs: item.path_globs ?? [],
+                component_tags: item.component_tags ?? [],
                 priority: item.priority ?? 'normal',
                 injection_mode: item.injection_mode ?? 'relevant',
                 status: item.state === 'active' ? 'active' : 'archived',
+                origin: item.origin,
                 created_at: item.created_at,
                 updated_at: item.updated_at,
             }))
-            : validatedArchive.memory.conventions;
-        const archiveDecisions = validatedArchive.schema_version === 3
-            ? validatedArchive.memory.items
+            : legacyConventions;
+        const archiveDecisions = archiveItems.length > 0 || validatedArchive.schema_version >= 3
+            ? archiveItems
                 .filter((item) => item.kind === 'decision')
                 .map(item => ({
                 title: item.title,
@@ -770,11 +1264,17 @@ export const importProjectMemoryArchive = (projectId, archiveValue) => {
                 decision: item.content,
                 rationale: item.rationale,
                 implications: item.implications,
+                stages: item.stages,
+                path_globs: item.path_globs ?? [],
+                component_tags: item.component_tags ?? [],
                 status: item.state === 'active' ? 'accepted' : item.state === 'archived' ? 'archived' : 'superseded',
+                archive_id: item.archive_id,
+                superseded_by_archive_id: item.superseded_by_archive_id,
+                origin: item.origin,
                 created_at: item.created_at,
                 updated_at: item.updated_at,
             }))
-            : validatedArchive.memory.decisions;
+            : legacyDecisions;
         const existingConventionRows = db.prepare(`
       SELECT *
       FROM project_conventions
@@ -814,12 +1314,16 @@ export const importProjectMemoryArchive = (projectId, archiveValue) => {
         instruction,
         rationale,
         stages_json,
+        path_globs_json,
+        component_tags_json,
         priority,
         injection_mode,
         status,
+        source_suggestion_id,
+        origin_json,
         created_at,
         updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
         const insertDecision = db.prepare(`
       INSERT INTO project_decisions (
@@ -830,10 +1334,15 @@ export const importProjectMemoryArchive = (projectId, archiveValue) => {
         decision,
         rationale,
         implications_json,
+        stages_json,
+        path_globs_json,
+        component_tags_json,
         status,
+        source_suggestion_id,
+        origin_json,
         created_at,
         updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
         const insertScan = db.prepare(`
       INSERT INTO project_context_scans (
@@ -845,11 +1354,17 @@ export const importProjectMemoryArchive = (projectId, archiveValue) => {
         scanner_tool,
         scanner_model,
         scanner_variant,
+        scanner_provider,
+        origin,
+        scanned_at,
+        completed_at,
+        working_tree_dirty,
+        manifest_json,
         summary_markdown,
         error,
         created_at,
         updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
         const insertArtifact = db.prepare(`
       INSERT INTO project_context_artifacts (
@@ -876,13 +1391,15 @@ export const importProjectMemoryArchive = (projectId, archiveValue) => {
                 result.conflicts.push(createConflict('convention', convention.title));
                 continue;
             }
-            insertConvention.run(randomUUID(), projectId, convention.title, convention.scope, convention.instruction, convention.rationale, convention.stages.length > 0 ? JSON.stringify(convention.stages) : null, convention.priority, convention.injection_mode, convention.status, convention.created_at, convention.updated_at);
+            insertConvention.run(randomUUID(), projectId, convention.title, convention.scope, convention.instruction, convention.rationale, convention.stages.length > 0 ? JSON.stringify(convention.stages) : null, convention.path_globs && convention.path_globs.length > 0 ? JSON.stringify(convention.path_globs) : null, convention.component_tags && convention.component_tags.length > 0 ? JSON.stringify(convention.component_tags) : null, convention.priority, convention.injection_mode, convention.status, null, JSON.stringify(getImportedArchiveOrigin(convention.origin, convention.created_at)), convention.created_at, convention.updated_at);
             conventionFingerprints.add(fingerprint);
             const nextTitleFingerprints = titleFingerprints ?? new Set();
             nextTitleFingerprints.add(fingerprint);
             conventionTitles.set(normalizedTitle, nextTitleFingerprints);
             result.summary.conventions_imported += 1;
         }
+        const importedDecisionIds = new Map();
+        const importedDecisionRelationships = [];
         for (const decision of archiveDecisions) {
             const fingerprint = fingerprintDecision(decision);
             const normalizedTitle = normalizeString(decision.title);
@@ -896,13 +1413,26 @@ export const importProjectMemoryArchive = (projectId, archiveValue) => {
                 result.conflicts.push(createConflict('decision', decision.title));
                 continue;
             }
-            insertDecision.run(randomUUID(), projectId, decision.title, decision.scope, decision.decision, decision.rationale, decision.implications.length > 0 ? JSON.stringify(decision.implications) : null, decision.status, decision.created_at, decision.updated_at);
+            const importedDecisionId = randomUUID();
+            insertDecision.run(importedDecisionId, projectId, decision.title, decision.scope, decision.decision, decision.rationale, decision.implications.length > 0 ? JSON.stringify(decision.implications) : null, decision.stages && decision.stages.length > 0 ? JSON.stringify(decision.stages) : null, decision.path_globs && decision.path_globs.length > 0 ? JSON.stringify(decision.path_globs) : null, decision.component_tags && decision.component_tags.length > 0 ? JSON.stringify(decision.component_tags) : null, decision.status, null, JSON.stringify(getImportedArchiveOrigin(decision.origin, decision.created_at)), decision.created_at, decision.updated_at);
+            if (decision.archive_id) {
+                importedDecisionIds.set(decision.archive_id, importedDecisionId);
+            }
+            if (decision.superseded_by_archive_id) {
+                importedDecisionRelationships.push({ decisionId: importedDecisionId, replacementArchiveId: decision.superseded_by_archive_id });
+            }
             decisionFingerprints.add(fingerprint);
             const nextTitleFingerprints = titleFingerprints ?? new Set();
             nextTitleFingerprints.add(fingerprint);
             decisionTitles.set(normalizedTitle, nextTitleFingerprints);
             result.summary.decisions_imported += 1;
         }
+        for (const relationship of importedDecisionRelationships) {
+            const replacementDecisionId = importedDecisionIds.get(relationship.replacementArchiveId);
+            if (replacementDecisionId) {
+                db.prepare('UPDATE project_decisions SET superseded_by_decision_id = ? WHERE id = ? AND project_id = ?').run(replacementDecisionId, relationship.decisionId, projectId);
+            }
+        }
         const scanFingerprintToId = new Map();
         for (const scanRow of existingScanRows) {
             scanFingerprintToId.set(fingerprintScan({
@@ -912,6 +1442,12 @@ export const importProjectMemoryArchive = (projectId, archiveValue) => {
                 scanner_tool: scanRow.scanner_tool,
                 scanner_model: scanRow.scanner_model,
                 scanner_variant: scanRow.scanner_variant,
+                scanner_provider: scanRow.scanner_provider,
+                origin: scanRow.origin,
+                scanned_at: scanRow.scanned_at,
+                completed_at: scanRow.completed_at,
+                working_tree_dirty: scanRow.working_tree_dirty == null ? null : Boolean(scanRow.working_tree_dirty),
+                manifest: parseStoredScanManifest(scanRow.manifest_json),
                 summary_markdown: scanRow.summary_markdown,
                 error: scanRow.error,
                 created_at: scanRow.created_at,
@@ -925,22 +1461,38 @@ export const importProjectMemoryArchive = (projectId, archiveValue) => {
             current.add(fingerprintArtifact(serializeArtifact(artifactRow)));
             artifactFingerprintsByScanId.set(artifactRow.scan_id, current);
         }
-        for (const scan of validatedArchive.memory.scans) {
-            const scanFingerprint = fingerprintScan(scan);
+        for (const archiveScan of validatedArchive.memory.scans) {
+            const scan = archiveScan.status === 'pending' || archiveScan.status === 'running'
+                ? {
+                    ...archiveScan,
+                    status: 'error',
+                    error: IMPORTED_ACTIVE_SCAN_ERROR,
+                }
+                : archiveScan;
+            const importedScan = {
+                ...scan,
+                origin: 'archive_import',
+                scanner_provider: scan.scanner_provider ?? null,
+                scanned_at: scan.scanned_at ?? scan.created_at,
+                completed_at: scan.completed_at ?? (scan.status === 'done' ? scan.updated_at : null),
+                working_tree_dirty: scan.working_tree_dirty ?? null,
+                manifest: scan.manifest ?? null,
+            };
+            const scanFingerprint = fingerprintScan(importedScan);
             let targetScanId = scanFingerprintToId.get(scanFingerprint);
             if (targetScanId) {
                 result.summary.scans_skipped += 1;
             }
             else {
                 targetScanId = randomUUID();
-                insertScan.run(targetScanId, projectId, scan.status, scan.repo_head, scan.repo_branch, scan.scanner_tool, scan.scanner_model, scan.scanner_variant, scan.summary_markdown, scan.error, scan.created_at, scan.updated_at);
+                insertScan.run(targetScanId, projectId, importedScan.status, importedScan.repo_head, importedScan.repo_branch, importedScan.scanner_tool, importedScan.scanner_model, importedScan.scanner_variant, importedScan.scanner_provider, importedScan.origin, importedScan.scanned_at, importedScan.completed_at, importedScan.working_tree_dirty == null ? null : Number(importedScan.working_tree_dirty), importedScan.manifest == null ? null : JSON.stringify(importedScan.manifest), importedScan.summary_markdown, importedScan.error, importedScan.created_at, importedScan.updated_at);
                 scanFingerprintToId.set(scanFingerprint, targetScanId);
                 artifactFingerprintsByScanId.set(targetScanId, new Set());
                 result.summary.scans_imported += 1;
             }
             const artifactFingerprints = artifactFingerprintsByScanId.get(targetScanId) ?? new Set();
             artifactFingerprintsByScanId.set(targetScanId, artifactFingerprints);
-            for (const artifact of scan.artifacts) {
+            for (const artifact of importedScan.artifacts) {
                 const artifactFingerprint = fingerprintArtifact(artifact);
                 if (artifactFingerprints.has(artifactFingerprint)) {
                     result.summary.artifacts_skipped += 1;