@straiffi/archon 1.0.0

package/dist/server/lib/projectMemory.js

@@ -0,0 +1,1519 @@
+import { randomUUID } from 'crypto';
+import db from '../db.js';
+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_MEMORY_KINDS = ['decision', 'convention'];
+const PROJECT_MEMORY_STATES = ['suggested', 'active', 'archived', 'superseded', 'dismissed', 'applied_to_existing'];
+const PROJECT_MEMORY_SOURCES = ['manual', 'agent'];
+const PROJECT_MEMORY_SUGGESTION_KINDS = ['decision', 'convention'];
+const PROJECT_MEMORY_SUGGESTION_STATUSES = ['pending', 'accepted', 'dismissed', 'applied_to_existing'];
+const PROJECT_MEMORY_SUGGESTION_DUPLICATE_KINDS = ['none', 'near_duplicate'];
+const PROJECT_CONTEXT_SCAN_STATUSES = ['pending', 'running', 'done', 'error'];
+const PROJECT_CONTEXT_ARTIFACT_KINDS = ['architecture', 'key_areas', 'conventions', 'risks'];
+const ACCEPTED_PROJECT_DECISION_STATUS = 'accepted';
+const ACCEPTED_MEMORY_COMPARISON_STOPWORDS = new Set([
+    'about',
+    'again',
+    'all',
+    'also',
+    'and',
+    'any',
+    'are',
+    'around',
+    'because',
+    'been',
+    'before',
+    'being',
+    'between',
+    'both',
+    'but',
+    'can',
+    'continue',
+    'default',
+    'does',
+    'during',
+    'each',
+    'for',
+    'from',
+    'have',
+    'into',
+    'its',
+    'just',
+    'keep',
+    'last',
+    'more',
+    'most',
+    'must',
+    'new',
+    'none',
+    'not',
+    'only',
+    'other',
+    'our',
+    'out',
+    'over',
+    'rather',
+    'same',
+    'should',
+    'still',
+    'such',
+    'than',
+    'that',
+    'the',
+    'their',
+    'them',
+    'then',
+    'there',
+    'these',
+    'this',
+    'those',
+    'through',
+    'use',
+    'used',
+    'using',
+    'when',
+    'while',
+    'with',
+    'without',
+]);
+const parseStringArray = (value) => {
+    if (!value) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed
+            .filter((entry) => typeof entry === 'string')
+            .map(entry => entry.trim())
+            .filter(Boolean)
+            .filter((entry, index, values) => values.indexOf(entry) === index);
+    }
+    catch {
+        return [];
+    }
+};
+const normalizeComparisonText = (value) => {
+    return String(value ?? '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, ' ')
+        .trim()
+        .replace(/\s+/g, ' ');
+};
+const tokenizeForComparison = (...parts) => {
+    return parts
+        .flatMap(part => normalizeComparisonText(part).split(' '))
+        .map(token => token.trim())
+        .filter(token => token.length >= 3);
+};
+const getComparisonTokenSet = (parts, { excludeStopwords = false } = {}) => {
+    const tokens = tokenizeForComparison(...parts)
+        .filter(token => !excludeStopwords || !ACCEPTED_MEMORY_COMPARISON_STOPWORDS.has(token));
+    return new Set(tokens);
+};
+const countTokenSetOverlap = (leftTokens, rightTokens) => {
+    let overlap = 0;
+    for (const token of leftTokens) {
+        if (rightTokens.has(token)) {
+            overlap += 1;
+        }
+    }
+    return overlap;
+};
+const getTokenSetCoverage = (leftTokens, rightTokens) => {
+    const smallerTokenCount = Math.min(leftTokens.size, rightTokens.size);
+    if (smallerTokenCount === 0) {
+        return 0;
+    }
+    return countTokenSetOverlap(leftTokens, rightTokens) / smallerTokenCount;
+};
+const countTokenOverlap = (leftParts, rightParts) => {
+    const leftTokens = getComparisonTokenSet(leftParts);
+    const rightTokens = getComparisonTokenSet(rightParts);
+    return countTokenSetOverlap(leftTokens, rightTokens);
+};
+const hasSubstantialContainment = (left, right) => {
+    const shorter = left.length <= right.length ? left : right;
+    const longer = left.length <= right.length ? right : left;
+    if (shorter.length < 24) {
+        return false;
+    }
+    return longer.includes(shorter);
+};
+const isAcceptedMemoryNearDuplicate = ({ suggestionTitle, suggestionScope, suggestionContent, targetTitle, targetScope, targetContent, }) => {
+    const sameTitle = suggestionTitle !== '' && suggestionTitle === targetTitle;
+    const sameScope = suggestionScope !== '' && suggestionScope === targetScope;
+    const contentOverlap = countTokenOverlap([suggestionContent], [targetContent]);
+    const fullOverlap = countTokenOverlap([suggestionTitle, suggestionScope, suggestionContent], [targetTitle, targetScope, targetContent]);
+    const distinctiveContentTokens = getComparisonTokenSet([suggestionContent], { excludeStopwords: true });
+    const distinctiveTargetContentTokens = getComparisonTokenSet([targetContent], { excludeStopwords: true });
+    const distinctiveFullSuggestionTokens = getComparisonTokenSet([suggestionTitle, suggestionScope, suggestionContent], { excludeStopwords: true });
+    const distinctiveFullTargetTokens = getComparisonTokenSet([targetTitle, targetScope, targetContent], { excludeStopwords: true });
+    const distinctiveContentOverlap = countTokenSetOverlap(distinctiveContentTokens, distinctiveTargetContentTokens);
+    const distinctiveFullOverlap = countTokenSetOverlap(distinctiveFullSuggestionTokens, distinctiveFullTargetTokens);
+    const distinctiveContentCoverage = getTokenSetCoverage(distinctiveContentTokens, distinctiveTargetContentTokens);
+    const distinctiveFullCoverage = getTokenSetCoverage(distinctiveFullSuggestionTokens, distinctiveFullTargetTokens);
+    const contentContainment = hasSubstantialContainment(suggestionContent, targetContent);
+    if (contentContainment && distinctiveContentOverlap >= 2 && (sameTitle || sameScope || distinctiveFullCoverage >= 0.45)) {
+        return true;
+    }
+    if (sameTitle && distinctiveContentOverlap >= 2 && distinctiveContentCoverage >= 0.35) {
+        return true;
+    }
+    if (sameScope && distinctiveContentOverlap >= 2 && distinctiveContentCoverage >= 0.5) {
+        return true;
+    }
+    return contentOverlap >= 5
+        && fullOverlap >= 7
+        && distinctiveContentOverlap >= 3
+        && distinctiveFullOverlap >= 3
+        && distinctiveContentCoverage >= 0.5
+        && distinctiveFullCoverage >= 0.35;
+};
+const normalizeOptionalString = (value, fieldName) => {
+    if (value == null) {
+        return { values: null };
+    }
+    if (typeof value !== 'string') {
+        return { error: `${fieldName} must be a string` };
+    }
+    const trimmed = value.trim();
+    return { values: trimmed === '' ? null : trimmed };
+};
+const validateRequiredString = (value, fieldName) => {
+    if (typeof value !== 'string' || value.trim() === '') {
+        return { error: `${fieldName} must be a non-empty string` };
+    }
+    return { values: value.trim() };
+};
+const validateStages = (value) => {
+    if (value == null) {
+        return { values: null };
+    }
+    if (!Array.isArray(value)) {
+        return { error: 'stages must be an array of valid project memory stages' };
+    }
+    const normalized = [];
+    for (const stage of value) {
+        if (!PROJECT_MEMORY_STAGES.includes(stage)) {
+            return { error: 'stages must be an array of valid project memory stages' };
+        }
+        if (!normalized.includes(stage)) {
+            normalized.push(stage);
+        }
+    }
+    return { values: normalized.length > 0 ? JSON.stringify(normalized) : null };
+};
+const validatePriority = (value) => {
+    if (!PROJECT_CONVENTION_PRIORITIES.includes(value)) {
+        return { error: 'priority must be one of critical, normal, or low' };
+    }
+    return { values: value };
+};
+const validateConventionInjectionMode = (value) => {
+    if (!PROJECT_CONVENTION_INJECTION_MODES.includes(value)) {
+        return { error: 'injection_mode must be one of always or relevant' };
+    }
+    return { values: value };
+};
+const validateImplications = (value) => {
+    if (value == null) {
+        return { values: null };
+    }
+    if (!Array.isArray(value)) {
+        return { error: 'implications must be an array of non-empty strings' };
+    }
+    const normalized = [];
+    for (const implication of value) {
+        if (typeof implication !== 'string' || implication.trim() === '') {
+            return { error: 'implications must be an array of non-empty strings' };
+        }
+        const trimmed = implication.trim();
+        if (!normalized.includes(trimmed)) {
+            normalized.push(trimmed);
+        }
+    }
+    return { values: normalized.length > 0 ? JSON.stringify(normalized) : null };
+};
+const serializeConvention = (row) => {
+    return {
+        id: row.id,
+        project_id: row.project_id,
+        title: row.title,
+        scope: row.scope,
+        instruction: row.instruction,
+        rationale: row.rationale,
+        stages: parseStringArray(row.stages_json).filter((stage) => PROJECT_MEMORY_STAGES.includes(stage)),
+        priority: row.priority,
+        injection_mode: PROJECT_CONVENTION_INJECTION_MODES.includes(row.injection_mode)
+            ? row.injection_mode
+            : 'relevant',
+        status: row.status,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+};
+const serializeDecision = (row) => {
+    return {
+        id: row.id,
+        project_id: row.project_id,
+        title: row.title,
+        scope: row.scope,
+        decision: row.decision,
+        rationale: row.rationale,
+        implications: parseStringArray(row.implications_json),
+        status: row.status,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+};
+export const serializeProjectMemoryFromConventionValue = (convention) => {
+    return {
+        id: convention.id,
+        project_id: convention.project_id,
+        kind: 'convention',
+        state: convention.status === 'active' ? 'active' : 'archived',
+        source: 'manual',
+        title: convention.title,
+        scope: convention.scope,
+        content: convention.instruction,
+        rationale: convention.rationale,
+        implications: [],
+        stages: convention.stages,
+        priority: convention.priority,
+        injection_mode: convention.injection_mode,
+        source_stage: null,
+        ticket_id: null,
+        chat_session_id: null,
+        duplicate_match: null,
+        created_at: convention.created_at,
+        updated_at: convention.updated_at,
+    };
+};
+const serializeProjectMemoryFromConvention = (row) => {
+    return serializeProjectMemoryFromConventionValue(serializeConvention(row));
+};
+export const serializeProjectMemoryFromDecisionValue = (decision) => {
+    return {
+        id: decision.id,
+        project_id: decision.project_id,
+        kind: 'decision',
+        state: decision.status === 'accepted' ? 'active' : decision.status,
+        source: 'manual',
+        title: decision.title,
+        scope: decision.scope,
+        content: decision.decision,
+        rationale: decision.rationale,
+        implications: decision.implications,
+        stages: [],
+        priority: null,
+        injection_mode: null,
+        source_stage: null,
+        ticket_id: null,
+        chat_session_id: null,
+        duplicate_match: null,
+        created_at: decision.created_at,
+        updated_at: decision.updated_at,
+    };
+};
+const serializeProjectMemoryFromDecision = (row) => {
+    return serializeProjectMemoryFromDecisionValue(serializeDecision(row));
+};
+const parseJsonValue = (value) => {
+    if (!value) {
+        return null;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+};
+const serializeProjectContextScan = (row) => {
+    return {
+        id: row.id,
+        project_id: row.project_id,
+        status: PROJECT_CONTEXT_SCAN_STATUSES.includes(row.status)
+            ? row.status
+            : 'error',
+        repo_head: row.repo_head,
+        repo_branch: row.repo_branch,
+        scanner_tool: row.scanner_tool === 'claude' || row.scanner_tool === 'opencode' ? row.scanner_tool : null,
+        scanner_model: row.scanner_model,
+        scanner_variant: row.scanner_variant,
+        summary_markdown: row.summary_markdown,
+        error: row.error,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+};
+const serializeProjectContextArtifact = (row) => {
+    return {
+        id: row.id,
+        scan_id: row.scan_id,
+        project_id: row.project_id,
+        kind: PROJECT_CONTEXT_ARTIFACT_KINDS.includes(row.kind)
+            ? row.kind
+            : 'risks',
+        title: row.title,
+        content_json: parseJsonValue(row.content_json),
+        content_markdown: row.content_markdown,
+        created_at: row.created_at,
+    };
+};
+const parseProjectMemorySuggestionDetails = (value) => {
+    if (!value) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+};
+const parseProjectMemorySuggestionValues = (row) => {
+    const details = parseProjectMemorySuggestionDetails(row.details_json);
+    if (row.kind === 'decision') {
+        const implications = Array.isArray(details.implications)
+            ? details.implications
+                .filter((entry) => typeof entry === 'string')
+                .map(entry => entry.trim())
+                .filter(Boolean)
+                .filter((entry, index, values) => values.indexOf(entry) === index)
+            : [];
+        return {
+            kind: 'decision',
+            title: row.title,
+            scope: row.scope,
+            decision: row.content_text,
+            rationale: row.rationale,
+            implications,
+        };
+    }
+    if (row.kind === 'convention') {
+        const stages = Array.isArray(details.stages)
+            ? details.stages
+                .filter((entry) => typeof entry === 'string' && PROJECT_MEMORY_STAGES.includes(entry))
+                .filter((entry, index, values) => values.indexOf(entry) === index)
+            : [];
+        const priority = PROJECT_CONVENTION_PRIORITIES.includes(details.priority)
+            ? details.priority
+            : 'normal';
+        const injectionMode = PROJECT_CONVENTION_INJECTION_MODES.includes(details.injection_mode)
+            ? details.injection_mode
+            : 'relevant';
+        return {
+            kind: 'convention',
+            title: row.title,
+            scope: row.scope,
+            instruction: row.content_text,
+            rationale: row.rationale,
+            stages,
+            priority,
+            injection_mode: injectionMode,
+        };
+    }
+    return null;
+};
+const getProjectMemorySuggestionContent = (suggestion) => {
+    return suggestion.kind === 'decision' ? suggestion.decision : suggestion.instruction;
+};
+const getProjectMemorySuggestionTextParts = (suggestion) => {
+    return [suggestion.title, suggestion.scope, getProjectMemorySuggestionContent(suggestion)];
+};
+export const getProjectMemorySuggestionDedupeKey = (suggestion) => {
+    const baseParts = [
+        suggestion.kind,
+        suggestion.title.toLowerCase(),
+        suggestion.scope?.toLowerCase() ?? '',
+        getProjectMemorySuggestionContent(suggestion).toLowerCase(),
+    ];
+    if (suggestion.kind === 'convention') {
+        baseParts.push(suggestion.stages.join(','), suggestion.priority);
+    }
+    return baseParts.join('::');
+};
+const serializeProjectMemorySuggestion = (row) => {
+    const values = parseProjectMemorySuggestionValues(row);
+    if (!values) {
+        return null;
+    }
+    const duplicateKind = PROJECT_MEMORY_SUGGESTION_DUPLICATE_KINDS.includes(row.duplicate_kind)
+        ? row.duplicate_kind
+        : 'none';
+    if (values.kind === 'decision') {
+        const duplicateDecision = duplicateKind === 'near_duplicate' && row.duplicate_target_id
+            ? getProjectDecisionById(row.project_id, row.duplicate_target_id)
+            : null;
+        return {
+            id: row.id,
+            project_id: row.project_id,
+            ticket_id: row.ticket_id,
+            chat_session_id: row.chat_session_id,
+            source_stage: row.source_stage,
+            kind: 'decision',
+            title: values.title,
+            scope: values.scope,
+            decision: values.decision,
+            rationale: values.rationale,
+            implications: values.implications,
+            status: row.status,
+            duplicate_match: duplicateDecision
+                ? {
+                    type: 'near_duplicate',
+                    decision: duplicateDecision,
+                }
+                : null,
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+        };
+    }
+    const duplicateConvention = duplicateKind === 'near_duplicate' && row.duplicate_target_id
+        ? getProjectConventionById(row.project_id, row.duplicate_target_id)
+        : null;
+    return {
+        id: row.id,
+        project_id: row.project_id,
+        ticket_id: row.ticket_id,
+        chat_session_id: row.chat_session_id,
+        source_stage: row.source_stage,
+        kind: 'convention',
+        title: values.title,
+        scope: values.scope,
+        instruction: values.instruction,
+        rationale: values.rationale,
+        stages: values.stages,
+        priority: values.priority,
+        injection_mode: values.injection_mode,
+        status: row.status,
+        duplicate_match: duplicateConvention
+            ? {
+                type: 'near_duplicate',
+                convention: duplicateConvention,
+            }
+            : null,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+};
+export const serializeProjectMemoryFromSuggestionValue = (suggestion) => {
+    if (suggestion.status === 'accepted') {
+        return null;
+    }
+    const state = suggestion.status === 'pending'
+        ? 'suggested'
+        : suggestion.status === 'dismissed'
+            ? 'dismissed'
+            : 'applied_to_existing';
+    if (suggestion.kind === 'decision') {
+        return {
+            id: suggestion.id,
+            project_id: suggestion.project_id,
+            kind: 'decision',
+            state,
+            source: 'agent',
+            title: suggestion.title,
+            scope: suggestion.scope,
+            content: suggestion.decision,
+            rationale: suggestion.rationale,
+            implications: suggestion.implications,
+            stages: [],
+            priority: null,
+            injection_mode: null,
+            source_stage: suggestion.source_stage,
+            ticket_id: suggestion.ticket_id,
+            chat_session_id: suggestion.chat_session_id,
+            duplicate_match: suggestion.duplicate_match?.decision
+                ? {
+                    type: 'near_duplicate',
+                    memory_id: suggestion.duplicate_match.decision.id,
+                    memory_kind: 'decision',
+                    title: suggestion.duplicate_match.decision.title,
+                    content: suggestion.duplicate_match.decision.decision,
+                }
+                : null,
+            created_at: suggestion.created_at,
+            updated_at: suggestion.updated_at,
+        };
+    }
+    return {
+        id: suggestion.id,
+        project_id: suggestion.project_id,
+        kind: 'convention',
+        state,
+        source: 'agent',
+        title: suggestion.title,
+        scope: suggestion.scope,
+        content: suggestion.instruction,
+        rationale: suggestion.rationale,
+        implications: [],
+        stages: suggestion.stages,
+        priority: suggestion.priority,
+        injection_mode: suggestion.injection_mode,
+        source_stage: suggestion.source_stage,
+        ticket_id: suggestion.ticket_id,
+        chat_session_id: suggestion.chat_session_id,
+        duplicate_match: suggestion.duplicate_match?.convention
+            ? {
+                type: 'near_duplicate',
+                memory_id: suggestion.duplicate_match.convention.id,
+                memory_kind: 'convention',
+                title: suggestion.duplicate_match.convention.title,
+                content: suggestion.duplicate_match.convention.instruction,
+            }
+            : null,
+        created_at: suggestion.created_at,
+        updated_at: suggestion.updated_at,
+    };
+};
+const serializeProjectMemoryFromSuggestion = (row) => {
+    const suggestion = serializeProjectMemorySuggestion(row);
+    return suggestion ? serializeProjectMemoryFromSuggestionValue(suggestion) : null;
+};
+export const isProjectMemoryEnabled = (project) => {
+    return Boolean(project?.memory_enabled);
+};
+export const getLatestProjectContextScan = (projectId) => {
+    const row = db.prepare(`
+    SELECT *
+    FROM project_context_scans
+    WHERE project_id = ?
+    ORDER BY created_at DESC, id DESC
+    LIMIT 1
+  `).get(projectId);
+    return row ? serializeProjectContextScan(row) : null;
+};
+export const getLatestSuccessfulProjectContextScan = (projectId) => {
+    const row = db.prepare(`
+    SELECT *
+    FROM project_context_scans
+    WHERE project_id = ?
+      AND status = 'done'
+    ORDER BY created_at DESC, id DESC
+    LIMIT 1
+  `).get(projectId);
+    return row ? serializeProjectContextScan(row) : null;
+};
+export const getActiveProjectContextScan = (projectId) => {
+    const row = db.prepare(`
+    SELECT *
+    FROM project_context_scans
+    WHERE project_id = ?
+      AND status IN ('pending', 'running')
+    ORDER BY created_at DESC, id DESC
+    LIMIT 1
+  `).get(projectId);
+    return row ? serializeProjectContextScan(row) : null;
+};
+export const getProjectContextScanById = (projectId, scanId) => {
+    const row = db.prepare(`
+    SELECT *
+    FROM project_context_scans
+    WHERE id = ?
+      AND project_id = ?
+  `).get(scanId, projectId);
+    return row ? serializeProjectContextScan(row) : null;
+};
+export const createProjectContextScan = (projectId, values) => {
+    const id = randomUUID();
+    db.prepare(`
+    INSERT INTO project_context_scans (
+      id,
+      project_id,
+      status,
+      repo_head,
+      repo_branch,
+      scanner_tool,
+      scanner_model,
+      scanner_variant,
+      summary_markdown,
+      error
+    )
+    VALUES (?, ?, 'pending', ?, ?, ?, ?, ?, NULL, NULL)
+  `).run(id, projectId, values.repo_head, values.repo_branch, values.scanner_tool, values.scanner_model, values.scanner_variant);
+    return getProjectContextScanById(projectId, id);
+};
+export const updateProjectContextScan = (projectId, scanId, values) => {
+    const current = getProjectContextScanById(projectId, scanId);
+    if (!current) {
+        return null;
+    }
+    db.prepare(`
+    UPDATE project_context_scans
+    SET status = ?,
+        repo_head = ?,
+        repo_branch = ?,
+        scanner_tool = ?,
+        scanner_model = ?,
+        scanner_variant = ?,
+        summary_markdown = ?,
+        error = ?,
+        updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+      AND project_id = ?
+  `).run(values.status ?? current.status, Object.hasOwn(values, 'repo_head') ? values.repo_head : current.repo_head, Object.hasOwn(values, 'repo_branch') ? values.repo_branch : current.repo_branch, Object.hasOwn(values, 'scanner_tool') ? values.scanner_tool : current.scanner_tool, Object.hasOwn(values, 'scanner_model') ? values.scanner_model : current.scanner_model, Object.hasOwn(values, 'scanner_variant') ? values.scanner_variant : current.scanner_variant, Object.hasOwn(values, 'summary_markdown') ? values.summary_markdown : current.summary_markdown, Object.hasOwn(values, 'error') ? values.error : current.error, scanId, projectId);
+    return getProjectContextScanById(projectId, scanId);
+};
+export const replaceProjectContextArtifacts = (projectId, scanId, artifacts) => {
+    const removeArtifacts = db.prepare('DELETE FROM project_context_artifacts WHERE scan_id = ? AND project_id = ?');
+    const insertArtifact = db.prepare(`
+    INSERT INTO project_context_artifacts (
+      id,
+      scan_id,
+      project_id,
+      kind,
+      title,
+      content_json,
+      content_markdown
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+    const transaction = db.transaction((nextArtifacts) => {
+        removeArtifacts.run(scanId, projectId);
+        for (const artifact of nextArtifacts) {
+            insertArtifact.run(randomUUID(), scanId, projectId, artifact.kind, artifact.title, artifact.content_json, artifact.content_markdown);
+        }
+    });
+    transaction(artifacts);
+    return listProjectContextArtifactsForScan(projectId, scanId);
+};
+export const listProjectContextArtifactsForScan = (projectId, scanId) => {
+    const rows = db.prepare(`
+    SELECT *
+    FROM project_context_artifacts
+    WHERE project_id = ?
+      AND scan_id = ?
+    ORDER BY created_at ASC, id ASC
+  `).all(projectId, scanId);
+    return rows.map(serializeProjectContextArtifact);
+};
+export const listLatestSuccessfulProjectContextArtifacts = (projectId) => {
+    const scan = getLatestSuccessfulProjectContextScan(projectId);
+    if (!scan) {
+        return [];
+    }
+    return listProjectContextArtifactsForScan(projectId, scan.id);
+};
+export const validateProjectConventionPayload = (body, { partial = false } = {}) => {
+    if (!body || typeof body !== 'object' || Array.isArray(body)) {
+        return { error: 'Invalid convention payload' };
+    }
+    const input = body;
+    const values = {};
+    if (!partial || Object.hasOwn(input, 'title')) {
+        const result = validateRequiredString(input.title, 'title');
+        if ('error' in result) {
+            return result;
+        }
+        values.title = result.values;
+    }
+    if (!partial || Object.hasOwn(input, 'instruction')) {
+        const result = validateRequiredString(input.instruction, 'instruction');
+        if ('error' in result) {
+            return result;
+        }
+        values.instruction = result.values;
+    }
+    if (Object.hasOwn(input, 'scope')) {
+        const result = normalizeOptionalString(input.scope, 'scope');
+        if ('error' in result) {
+            return result;
+        }
+        values.scope = result.values;
+    }
+    else if (!partial) {
+        values.scope = null;
+    }
+    if (Object.hasOwn(input, 'rationale')) {
+        const result = normalizeOptionalString(input.rationale, 'rationale');
+        if ('error' in result) {
+            return result;
+        }
+        values.rationale = result.values;
+    }
+    else if (!partial) {
+        values.rationale = null;
+    }
+    if (Object.hasOwn(input, 'stages')) {
+        const result = validateStages(input.stages);
+        if ('error' in result) {
+            return result;
+        }
+        values.stages_json = result.values;
+    }
+    else if (!partial) {
+        values.stages_json = null;
+    }
+    if (Object.hasOwn(input, 'priority')) {
+        const result = validatePriority(input.priority);
+        if ('error' in result) {
+            return result;
+        }
+        values.priority = result.values;
+    }
+    else if (!partial) {
+        values.priority = 'normal';
+    }
+    if (Object.hasOwn(input, 'injection_mode')) {
+        const result = validateConventionInjectionMode(input.injection_mode);
+        if ('error' in result) {
+            return result;
+        }
+        values.injection_mode = result.values;
+    }
+    else if (!partial) {
+        values.injection_mode = 'relevant';
+    }
+    return { values };
+};
+export const validateProjectDecisionPayload = (body, { partial = false } = {}) => {
+    if (!body || typeof body !== 'object' || Array.isArray(body)) {
+        return { error: 'Invalid decision payload' };
+    }
+    const input = body;
+    const values = {};
+    if (!partial || Object.hasOwn(input, 'title')) {
+        const result = validateRequiredString(input.title, 'title');
+        if ('error' in result) {
+            return result;
+        }
+        values.title = result.values;
+    }
+    if (!partial || Object.hasOwn(input, 'decision')) {
+        const result = validateRequiredString(input.decision, 'decision');
+        if ('error' in result) {
+            return result;
+        }
+        values.decision = result.values;
+    }
+    if (Object.hasOwn(input, 'scope')) {
+        const result = normalizeOptionalString(input.scope, 'scope');
+        if ('error' in result) {
+            return result;
+        }
+        values.scope = result.values;
+    }
+    else if (!partial) {
+        values.scope = null;
+    }
+    if (Object.hasOwn(input, 'rationale')) {
+        const result = normalizeOptionalString(input.rationale, 'rationale');
+        if ('error' in result) {
+            return result;
+        }
+        values.rationale = result.values;
+    }
+    else if (!partial) {
+        values.rationale = null;
+    }
+    if (Object.hasOwn(input, 'implications')) {
+        const result = validateImplications(input.implications);
+        if ('error' in result) {
+            return result;
+        }
+        values.implications_json = result.values;
+    }
+    else if (!partial) {
+        values.implications_json = null;
+    }
+    return { values };
+};
+export const validateProjectMemorySuggestionPayload = (body) => {
+    if (!body || typeof body !== 'object' || Array.isArray(body)) {
+        return { error: 'Invalid project memory suggestion payload' };
+    }
+    const input = body;
+    if (!PROJECT_MEMORY_SUGGESTION_KINDS.includes(input.kind)) {
+        return { error: 'kind must be one of decision or convention' };
+    }
+    if (input.kind === 'decision') {
+        const decisionValidation = validateProjectDecisionPayload({
+            title: input.title,
+            scope: input.scope,
+            decision: input.decision ?? input.content,
+            rationale: input.rationale,
+            implications: input.implications,
+        });
+        if ('error' in decisionValidation) {
+            return { error: decisionValidation.error };
+        }
+        return {
+            values: {
+                kind: 'decision',
+                title: decisionValidation.values.title ?? '',
+                scope: decisionValidation.values.scope ?? null,
+                decision: decisionValidation.values.decision ?? '',
+                rationale: decisionValidation.values.rationale ?? null,
+                implications: parseStringArray(decisionValidation.values.implications_json ?? null),
+            },
+        };
+    }
+    const conventionValidation = validateProjectConventionPayload({
+        title: input.title,
+        scope: input.scope,
+        instruction: input.instruction ?? input.content,
+        rationale: input.rationale,
+        stages: input.stages,
+        priority: input.priority,
+        injection_mode: input.injection_mode,
+    });
+    if ('error' in conventionValidation) {
+        return { error: conventionValidation.error };
+    }
+    const scope = conventionValidation.values.scope ?? null;
+    const stages = parseStringArray(conventionValidation.values.stages_json ?? null)
+        .filter((entry) => PROJECT_MEMORY_STAGES.includes(entry));
+    if (!scope && stages.length === 0) {
+        return { error: 'Convention suggestions require a scope or at least one stage' };
+    }
+    return {
+        values: {
+            kind: 'convention',
+            title: conventionValidation.values.title ?? '',
+            scope,
+            instruction: conventionValidation.values.instruction ?? '',
+            rationale: conventionValidation.values.rationale ?? null,
+            stages,
+            priority: conventionValidation.values.priority ?? 'normal',
+            injection_mode: conventionValidation.values.injection_mode ?? 'relevant',
+        },
+    };
+};
+export const classifyProjectMemorySuggestionDuplicate = ({ suggestion, activeConventions, activeDecisions, pendingSuggestions, }) => {
+    const normalizedSuggestionContent = normalizeComparisonText(getProjectMemorySuggestionContent(suggestion));
+    const normalizedSuggestionTitle = normalizeComparisonText(suggestion.title);
+    const normalizedSuggestionScope = normalizeComparisonText(suggestion.scope);
+    if (suggestion.kind === 'decision') {
+        for (const decision of activeDecisions) {
+            const normalizedDecisionText = normalizeComparisonText(decision.decision);
+            const normalizedDecisionTitle = normalizeComparisonText(decision.title);
+            const normalizedDecisionScope = normalizeComparisonText(decision.scope);
+            if (normalizedDecisionText !== ''
+                && normalizedDecisionText === normalizedSuggestionContent) {
+                return {
+                    action: 'suppress',
+                    reason: 'exact_duplicate',
+                    target: 'decision',
+                    targetId: decision.id,
+                    targetTitle: decision.title,
+                };
+            }
+            if (isAcceptedMemoryNearDuplicate({
+                suggestionTitle: normalizedSuggestionTitle,
+                suggestionScope: normalizedSuggestionScope,
+                suggestionContent: normalizedSuggestionContent,
+                targetTitle: normalizedDecisionTitle,
+                targetScope: normalizedDecisionScope,
+                targetContent: normalizedDecisionText,
+            })) {
+                return {
+                    action: 'mark_near_duplicate',
+                    targetMemoryKind: 'decision',
+                    targetMemoryId: decision.id,
+                    targetMemoryTitle: decision.title,
+                };
+            }
+        }
+    }
+    else {
+        for (const convention of activeConventions) {
+            const normalizedConventionInstruction = normalizeComparisonText(convention.instruction);
+            const normalizedConventionTitle = normalizeComparisonText(convention.title);
+            const normalizedConventionScope = normalizeComparisonText(convention.scope);
+            if (normalizedConventionInstruction !== ''
+                && normalizedConventionInstruction === normalizedSuggestionContent) {
+                return {
+                    action: 'suppress',
+                    reason: 'exact_duplicate',
+                    target: 'convention',
+                    targetId: convention.id,
+                    targetTitle: convention.title,
+                };
+            }
+            if (isAcceptedMemoryNearDuplicate({
+                suggestionTitle: normalizedSuggestionTitle,
+                suggestionScope: normalizedSuggestionScope,
+                suggestionContent: normalizedSuggestionContent,
+                targetTitle: normalizedConventionTitle,
+                targetScope: normalizedConventionScope,
+                targetContent: normalizedConventionInstruction,
+            })) {
+                return {
+                    action: 'mark_near_duplicate',
+                    targetMemoryKind: 'convention',
+                    targetMemoryId: convention.id,
+                    targetMemoryTitle: convention.title,
+                };
+            }
+        }
+    }
+    for (const pendingSuggestion of pendingSuggestions) {
+        if (pendingSuggestion.kind !== suggestion.kind) {
+            continue;
+        }
+        const samePendingContent = normalizeComparisonText(getProjectMemorySuggestionContent(pendingSuggestion)) === normalizedSuggestionContent;
+        const samePendingTitle = normalizeComparisonText(pendingSuggestion.title) === normalizedSuggestionTitle;
+        const overlap = countTokenOverlap(getProjectMemorySuggestionTextParts(suggestion), getProjectMemorySuggestionTextParts(pendingSuggestion));
+        if (samePendingContent || samePendingTitle || overlap >= 4) {
+            return {
+                action: 'suppress',
+                reason: 'pending_duplicate',
+                target: 'pending_suggestion',
+                targetId: pendingSuggestion.id,
+                targetTitle: pendingSuggestion.title,
+            };
+        }
+    }
+    return null;
+};
+export const listProjectConventions = (projectId, { includeArchived = false } = {}) => {
+    const rows = db.prepare(`
+    SELECT *
+    FROM project_conventions
+    WHERE project_id = ?
+      ${includeArchived ? '' : "AND status = 'active'"}
+    ORDER BY
+      CASE status WHEN 'active' THEN 0 ELSE 1 END,
+      updated_at DESC,
+      created_at DESC,
+      id DESC
+  `).all(projectId);
+    return rows.map(serializeConvention);
+};
+export const listProjectDecisions = (projectId, { includeArchived = false } = {}) => {
+    const rows = db.prepare(`
+    SELECT *
+    FROM project_decisions
+    WHERE project_id = ?
+      ${includeArchived ? '' : `AND status = '${ACCEPTED_PROJECT_DECISION_STATUS}'`}
+    ORDER BY
+      CASE status WHEN '${ACCEPTED_PROJECT_DECISION_STATUS}' THEN 0 ELSE 1 END,
+      updated_at DESC,
+      created_at DESC,
+      id DESC
+  `).all(projectId);
+    return rows.map(serializeDecision);
+};
+export const getProjectConventionById = (projectId, conventionId) => {
+    const row = db.prepare('SELECT * FROM project_conventions WHERE id = ? AND project_id = ?').get(conventionId, projectId);
+    return row ? serializeConvention(row) : null;
+};
+export const getProjectDecisionById = (projectId, decisionId) => {
+    const row = db.prepare('SELECT * FROM project_decisions WHERE id = ? AND project_id = ?').get(decisionId, projectId);
+    return row ? serializeDecision(row) : null;
+};
+export const createProjectConvention = (projectId, values) => {
+    const id = randomUUID();
+    db.prepare(`
+    INSERT INTO project_conventions (id, project_id, title, scope, instruction, rationale, stages_json, priority, injection_mode, status)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'active')
+  `).run(id, projectId, values.title, values.scope, values.instruction, values.rationale, values.stages_json, values.priority, values.injection_mode);
+    return getProjectConventionById(projectId, id);
+};
+export const updateProjectConvention = (projectId, conventionId, values) => {
+    const current = getProjectConventionById(projectId, conventionId);
+    if (!current) {
+        return null;
+    }
+    db.prepare(`
+    UPDATE project_conventions
+    SET title = ?,
+        scope = ?,
+        instruction = ?,
+        rationale = ?,
+        stages_json = ?,
+        priority = ?,
+        injection_mode = ?,
+        updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+      AND project_id = ?
+  `).run(values.title ?? current.title, Object.hasOwn(values, 'scope') ? values.scope : current.scope, values.instruction ?? current.instruction, Object.hasOwn(values, 'rationale') ? values.rationale : current.rationale, Object.hasOwn(values, 'stages_json') ? values.stages_json : (current.stages.length > 0 ? JSON.stringify(current.stages) : null), values.priority ?? current.priority, values.injection_mode ?? current.injection_mode, conventionId, projectId);
+    return getProjectConventionById(projectId, conventionId);
+};
+export const archiveProjectConvention = (projectId, conventionId) => {
+    db.prepare(`
+    UPDATE project_conventions
+    SET status = 'archived', updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+      AND project_id = ?
+  `).run(conventionId, projectId);
+    return getProjectConventionById(projectId, conventionId);
+};
+export const restoreProjectConvention = (projectId, conventionId) => {
+    db.prepare(`
+    UPDATE project_conventions
+    SET status = 'active', updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+      AND project_id = ?
+  `).run(conventionId, projectId);
+    return getProjectConventionById(projectId, conventionId);
+};
+export const createProjectDecision = (projectId, values) => {
+    const id = randomUUID();
+    db.prepare(`
+    INSERT INTO project_decisions (id, project_id, title, scope, decision, rationale, implications_json, status)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, projectId, values.title, values.scope, values.decision, values.rationale, values.implications_json, ACCEPTED_PROJECT_DECISION_STATUS);
+    return getProjectDecisionById(projectId, id);
+};
+export const updateProjectDecision = (projectId, decisionId, values) => {
+    const current = getProjectDecisionById(projectId, decisionId);
+    if (!current) {
+        return null;
+    }
+    db.prepare(`
+    UPDATE project_decisions
+    SET title = ?,
+        scope = ?,
+        decision = ?,
+        rationale = ?,
+        implications_json = ?,
+        updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+      AND project_id = ?
+  `).run(values.title ?? current.title, Object.hasOwn(values, 'scope') ? values.scope : current.scope, values.decision ?? current.decision, Object.hasOwn(values, 'rationale') ? values.rationale : current.rationale, Object.hasOwn(values, 'implications_json') ? values.implications_json : (current.implications.length > 0 ? JSON.stringify(current.implications) : null), decisionId, projectId);
+    return getProjectDecisionById(projectId, decisionId);
+};
+export const archiveProjectDecision = (projectId, decisionId) => {
+    db.prepare(`
+    UPDATE project_decisions
+    SET status = 'archived', updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+      AND project_id = ?
+  `).run(decisionId, projectId);
+    return getProjectDecisionById(projectId, decisionId);
+};
+export const supersedeProjectDecision = (projectId, decisionId) => {
+    db.prepare(`
+    UPDATE project_decisions
+    SET status = 'superseded', updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+      AND project_id = ?
+  `).run(decisionId, projectId);
+    return getProjectDecisionById(projectId, decisionId);
+};
+export const restoreProjectDecision = (projectId, decisionId) => {
+    db.prepare(`
+    UPDATE project_decisions
+    SET status = ?, updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+      AND project_id = ?
+  `).run(ACCEPTED_PROJECT_DECISION_STATUS, decisionId, projectId);
+    return getProjectDecisionById(projectId, decisionId);
+};
+const getProjectMemorySuggestionRowById = (projectId, suggestionId) => {
+    return db.prepare(`
+    SELECT *
+    FROM project_memory_suggestions
+    WHERE id = ?
+      AND project_id = ?
+  `).get(suggestionId, projectId);
+};
+const listProjectMemorySuggestionRows = (projectId, { ticketId, chatSessionId, status = 'pending', } = {}) => {
+    const rows = db.prepare(`
+    SELECT *
+    FROM project_memory_suggestions
+    WHERE project_id = ?
+      ${ticketId ? 'AND ticket_id = ?' : ''}
+      ${chatSessionId ? 'AND chat_session_id = ?' : ''}
+      ${status ? 'AND status = ?' : ''}
+    ORDER BY
+      updated_at DESC,
+      created_at DESC,
+      id DESC
+  `).all(...([
+        projectId,
+        ...(ticketId ? [ticketId] : []),
+        ...(chatSessionId ? [chatSessionId] : []),
+        ...(status ? [status] : []),
+    ]));
+    return rows.filter(row => PROJECT_MEMORY_SUGGESTION_STATUSES.includes(row.status));
+};
+const listResolvedProjectMemoryIdsForChatSession = (projectId, chatSessionId) => {
+    return new Set(listProjectMemorySuggestionRows(projectId, { chatSessionId, status: null })
+        .filter(row => {
+        return (row.status === 'accepted' || row.status === 'applied_to_existing')
+            && typeof row.resolved_memory_id === 'string'
+            && row.resolved_memory_id.trim().length > 0;
+    })
+        .map(row => row.resolved_memory_id));
+};
+const toProjectMemorySuggestionCandidate = (row) => {
+    const values = parseProjectMemorySuggestionValues(row);
+    if (!values) {
+        return null;
+    }
+    return {
+        id: row.id,
+        ...values,
+    };
+};
+export const listProjectMemorySuggestions = (projectId, { ticketId, chatSessionId, status = 'pending', } = {}) => {
+    return listProjectMemorySuggestionRows(projectId, { ticketId, chatSessionId, status })
+        .map(serializeProjectMemorySuggestion)
+        .filter((suggestion) => suggestion !== null);
+};
+export const listProjectMemories = (projectId, { states, kinds, sources, ticketId, chatSessionId, } = {}) => {
+    const allowedStates = (states ?? []).filter(state => PROJECT_MEMORY_STATES.includes(state));
+    const allowedKinds = (kinds ?? []).filter(kind => PROJECT_MEMORY_KINDS.includes(kind));
+    const allowedSources = (sources ?? []).filter(source => PROJECT_MEMORY_SOURCES.includes(source));
+    const memories = [
+        ...listProjectConventions(projectId, { includeArchived: true }).map(convention => serializeProjectMemoryFromConvention({
+            id: convention.id,
+            project_id: convention.project_id,
+            title: convention.title,
+            scope: convention.scope,
+            instruction: convention.instruction,
+            rationale: convention.rationale,
+            stages_json: convention.stages.length > 0 ? JSON.stringify(convention.stages) : null,
+            priority: convention.priority,
+            injection_mode: convention.injection_mode,
+            status: convention.status,
+            created_at: convention.created_at,
+            updated_at: convention.updated_at,
+        })),
+        ...listProjectDecisions(projectId, { includeArchived: true }).map(decision => serializeProjectMemoryFromDecision({
+            id: decision.id,
+            project_id: decision.project_id,
+            title: decision.title,
+            scope: decision.scope,
+            decision: decision.decision,
+            rationale: decision.rationale,
+            implications_json: decision.implications.length > 0 ? JSON.stringify(decision.implications) : null,
+            status: decision.status,
+            created_at: decision.created_at,
+            updated_at: decision.updated_at,
+        })),
+        ...listProjectMemorySuggestionRows(projectId, {
+            ticketId,
+            chatSessionId,
+            status: null,
+        })
+            .map(serializeProjectMemoryFromSuggestion)
+            .filter((memory) => memory !== null),
+    ];
+    return memories
+        .filter(memory => allowedStates.length === 0 || allowedStates.includes(memory.state))
+        .filter(memory => allowedKinds.length === 0 || allowedKinds.includes(memory.kind))
+        .filter(memory => allowedSources.length === 0 || allowedSources.includes(memory.source))
+        .sort((left, right) => {
+        const stateOrder = {
+            suggested: 0,
+            active: 1,
+            archived: 2,
+            superseded: 3,
+            dismissed: 4,
+            applied_to_existing: 5,
+        };
+        if (stateOrder[left.state] !== stateOrder[right.state]) {
+            return stateOrder[left.state] - stateOrder[right.state];
+        }
+        return right.updated_at.localeCompare(left.updated_at) || right.created_at.localeCompare(left.created_at) || right.id.localeCompare(left.id);
+    });
+};
+export const getProjectMemorySuggestionById = (projectId, suggestionId) => {
+    const row = getProjectMemorySuggestionRowById(projectId, suggestionId);
+    return row ? serializeProjectMemorySuggestion(row) : null;
+};
+export const getProjectMemoryById = (projectId, memoryId) => {
+    const convention = getProjectConventionById(projectId, memoryId);
+    if (convention) {
+        return serializeProjectMemoryFromConventionValue(convention);
+    }
+    const decision = getProjectDecisionById(projectId, memoryId);
+    if (decision) {
+        return serializeProjectMemoryFromDecisionValue(decision);
+    }
+    const suggestion = getProjectMemorySuggestionById(projectId, memoryId);
+    return suggestion ? serializeProjectMemoryFromSuggestionValue(suggestion) : null;
+};
+const persistProjectMemorySuggestionsForSource = (projectId, source, sourceStage, suggestions) => {
+    if (!source.ticketId && !source.chatSessionId) {
+        return [];
+    }
+    if (suggestions.length === 0) {
+        return [];
+    }
+    const activeDecisions = listProjectDecisions(projectId);
+    const activeConventions = listProjectConventions(projectId);
+    const pendingSuggestionCandidates = listProjectMemorySuggestionRows(projectId, { status: 'pending' })
+        .map(toProjectMemorySuggestionCandidate)
+        .filter((candidate) => candidate !== null);
+    const resolvedChatSessionMemoryIds = source.chatSessionId
+        ? listResolvedProjectMemoryIdsForChatSession(projectId, source.chatSessionId)
+        : new Set();
+    const createdIds = [];
+    for (const suggestion of suggestions) {
+        const duplicate = classifyProjectMemorySuggestionDuplicate({
+            suggestion,
+            activeConventions,
+            activeDecisions,
+            pendingSuggestions: pendingSuggestionCandidates,
+        });
+        if (duplicate?.action === 'suppress') {
+            continue;
+        }
+        if (duplicate?.action === 'mark_near_duplicate'
+            && source.chatSessionId
+            && resolvedChatSessionMemoryIds.has(duplicate.targetMemoryId)) {
+            continue;
+        }
+        const id = randomUUID();
+        db.prepare(`
+      INSERT INTO project_memory_suggestions (
+        id,
+        project_id,
+        ticket_id,
+        chat_session_id,
+        source_stage,
+        kind,
+        title,
+        scope,
+        content_text,
+        rationale,
+        details_json,
+        duplicate_kind,
+        duplicate_target_id,
+        status,
+        resolved_memory_id
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', NULL)
+    `).run(id, projectId, source.ticketId ?? null, source.chatSessionId ?? null, sourceStage, suggestion.kind, suggestion.title, suggestion.scope, getProjectMemorySuggestionContent(suggestion), suggestion.rationale, JSON.stringify(suggestion.kind === 'decision'
+            ? { implications: suggestion.implications }
+            : { stages: suggestion.stages, priority: suggestion.priority, injection_mode: suggestion.injection_mode }), duplicate?.action === 'mark_near_duplicate' ? 'near_duplicate' : 'none', duplicate?.action === 'mark_near_duplicate' ? duplicate.targetMemoryId : null);
+        createdIds.push(id);
+        pendingSuggestionCandidates.push({ id, ...suggestion });
+    }
+    return createdIds
+        .map(id => getProjectMemorySuggestionById(projectId, id))
+        .filter((suggestion) => suggestion !== null);
+};
+export const persistProjectMemorySuggestions = (projectId, ticketId, sourceStage, suggestions) => {
+    return persistProjectMemorySuggestionsForSource(projectId, { ticketId }, sourceStage, suggestions);
+};
+export const persistChatSessionProjectMemorySuggestions = (projectId, chatSessionId, suggestions) => {
+    return persistProjectMemorySuggestionsForSource(projectId, { chatSessionId }, 'chat', suggestions);
+};
+const updateProjectMemorySuggestionStatus = (projectId, suggestionId, status, resolvedMemoryId) => {
+    db.prepare(`
+    UPDATE project_memory_suggestions
+    SET status = ?,
+        resolved_memory_id = ?,
+        updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+      AND project_id = ?
+  `).run(status, resolvedMemoryId, suggestionId, projectId);
+    return getProjectMemorySuggestionById(projectId, suggestionId);
+};
+const mergeProjectMemorySuggestionDecisionValues = (suggestion, overrides) => {
+    if (suggestion.kind !== 'decision') {
+        return { error: 'Suggestion is not a decision' };
+    }
+    const merged = {
+        title: overrides.title ?? suggestion.title,
+        scope: Object.hasOwn(overrides, 'scope') ? overrides.scope : suggestion.scope,
+        decision: overrides.decision ?? suggestion.decision,
+        rationale: Object.hasOwn(overrides, 'rationale') ? overrides.rationale : suggestion.rationale,
+        implications: Object.hasOwn(overrides, 'implications_json')
+            ? parseStringArray(overrides.implications_json)
+            : suggestion.implications,
+    };
+    return validateProjectDecisionPayload(merged);
+};
+const mergeProjectMemorySuggestionConventionValues = (suggestion, overrides) => {
+    if (suggestion.kind !== 'convention') {
+        return { error: 'Suggestion is not a convention' };
+    }
+    const merged = {
+        title: overrides.title ?? suggestion.title,
+        scope: Object.hasOwn(overrides, 'scope') ? overrides.scope : suggestion.scope,
+        instruction: overrides.instruction ?? suggestion.instruction,
+        rationale: Object.hasOwn(overrides, 'rationale') ? overrides.rationale : suggestion.rationale,
+        stages: Object.hasOwn(overrides, 'stages_json')
+            ? parseStringArray(overrides.stages_json)
+            : suggestion.stages,
+        priority: overrides.priority ?? suggestion.priority,
+        injection_mode: overrides.injection_mode ?? suggestion.injection_mode,
+    };
+    return validateProjectConventionPayload(merged);
+};
+export const dismissProjectMemorySuggestion = (projectId, suggestionId) => {
+    return updateProjectMemorySuggestionStatus(projectId, suggestionId, 'dismissed', null);
+};
+export const acceptProjectMemorySuggestion = (projectId, suggestionId, overrides = {}) => {
+    const suggestion = getProjectMemorySuggestionById(projectId, suggestionId);
+    if (!suggestion) {
+        return { status: 404, error: 'Suggestion not found' };
+    }
+    return suggestion.kind === 'decision'
+        ? acceptProjectMemorySuggestionAsDecision(projectId, suggestionId, overrides)
+        : acceptProjectMemorySuggestionAsConvention(projectId, suggestionId, overrides);
+};
+export const acceptProjectMemorySuggestionAsDecision = (projectId, suggestionId, overrides = {}) => {
+    const suggestion = getProjectMemorySuggestionById(projectId, suggestionId);
+    if (!suggestion) {
+        return { status: 404, error: 'Suggestion not found' };
+    }
+    if (suggestion.status !== 'pending') {
+        return { status: 409, error: 'Suggestion is no longer pending', suggestion };
+    }
+    const merged = mergeProjectMemorySuggestionDecisionValues(suggestion, overrides);
+    if ('error' in merged) {
+        return { status: 400, error: merged.error, suggestion };
+    }
+    const duplicate = classifyProjectMemorySuggestionDuplicate({
+        suggestion: {
+            kind: 'decision',
+            title: merged.values.title ?? '',
+            scope: merged.values.scope ?? null,
+            decision: merged.values.decision ?? '',
+            rationale: merged.values.rationale ?? null,
+            implications: parseStringArray(merged.values.implications_json ?? null),
+        },
+        activeConventions: [],
+        activeDecisions: listProjectDecisions(projectId),
+        pendingSuggestions: listProjectMemorySuggestionRows(projectId, { status: 'pending' })
+            .filter(row => row.id !== suggestionId)
+            .map(toProjectMemorySuggestionCandidate)
+            .filter((candidate) => candidate !== null),
+    });
+    if (duplicate?.action === 'suppress' && duplicate.target === 'decision') {
+        return { status: 409, error: 'A matching decision already exists for this project', suggestion };
+    }
+    const createdDecision = createProjectDecision(projectId, {
+        title: merged.values.title ?? '',
+        scope: merged.values.scope ?? null,
+        decision: merged.values.decision ?? '',
+        rationale: merged.values.rationale ?? null,
+        implications_json: merged.values.implications_json ?? null,
+    });
+    if (!createdDecision) {
+        return { status: 500, error: 'Unable to create the suggested decision', suggestion };
+    }
+    const updatedSuggestion = updateProjectMemorySuggestionStatus(projectId, suggestionId, 'accepted', createdDecision.id);
+    if (!updatedSuggestion) {
+        return { status: 500, error: 'Unable to update the suggestion state', suggestion };
+    }
+    return {
+        suggestion: updatedSuggestion,
+        decision: createdDecision,
+    };
+};
+export const acceptProjectMemorySuggestionAsConvention = (projectId, suggestionId, overrides = {}) => {
+    const suggestion = getProjectMemorySuggestionById(projectId, suggestionId);
+    if (!suggestion) {
+        return { status: 404, error: 'Suggestion not found' };
+    }
+    if (suggestion.status !== 'pending') {
+        return { status: 409, error: 'Suggestion is no longer pending', suggestion };
+    }
+    const merged = mergeProjectMemorySuggestionConventionValues(suggestion, overrides);
+    if ('error' in merged) {
+        return { status: 400, error: merged.error, suggestion };
+    }
+    const duplicate = classifyProjectMemorySuggestionDuplicate({
+        suggestion: {
+            kind: 'convention',
+            title: merged.values.title ?? '',
+            scope: merged.values.scope ?? null,
+            instruction: merged.values.instruction ?? '',
+            rationale: merged.values.rationale ?? null,
+            stages: parseStringArray(merged.values.stages_json ?? null)
+                .filter((entry) => PROJECT_MEMORY_STAGES.includes(entry)),
+            priority: merged.values.priority ?? 'normal',
+            injection_mode: merged.values.injection_mode ?? 'relevant',
+        },
+        activeConventions: listProjectConventions(projectId),
+        activeDecisions: [],
+        pendingSuggestions: listProjectMemorySuggestionRows(projectId, { status: 'pending' })
+            .filter(row => row.id !== suggestionId)
+            .map(toProjectMemorySuggestionCandidate)
+            .filter((candidate) => candidate !== null),
+    });
+    if (duplicate?.action === 'suppress' && duplicate.target === 'convention') {
+        return { status: 409, error: 'A matching convention already exists for this project', suggestion };
+    }
+    const createdConvention = createProjectConvention(projectId, {
+        title: merged.values.title ?? '',
+        scope: merged.values.scope ?? null,
+        instruction: merged.values.instruction ?? '',
+        rationale: merged.values.rationale ?? null,
+        stages_json: merged.values.stages_json ?? null,
+        priority: merged.values.priority ?? 'normal',
+        injection_mode: merged.values.injection_mode ?? 'relevant',
+    });
+    if (!createdConvention) {
+        return { status: 500, error: 'Unable to create the suggested convention', suggestion };
+    }
+    const updatedSuggestion = updateProjectMemorySuggestionStatus(projectId, suggestionId, 'accepted', createdConvention.id);
+    if (!updatedSuggestion) {
+        return { status: 500, error: 'Unable to update the suggestion state', suggestion };
+    }
+    return {
+        suggestion: updatedSuggestion,
+        convention: createdConvention,
+    };
+};
+export const applyProjectMemorySuggestionToDecision = (projectId, suggestionId, decisionId, overrides = {}) => {
+    const suggestion = getProjectMemorySuggestionById(projectId, suggestionId);
+    if (!suggestion) {
+        return { status: 404, error: 'Suggestion not found' };
+    }
+    if (suggestion.status !== 'pending') {
+        return { status: 409, error: 'Suggestion is no longer pending', suggestion };
+    }
+    const existingDecision = getProjectDecisionById(projectId, decisionId);
+    if (!existingDecision || existingDecision.status !== ACCEPTED_PROJECT_DECISION_STATUS) {
+        return { status: 404, error: 'Decision not found', suggestion };
+    }
+    const merged = mergeProjectMemorySuggestionDecisionValues(suggestion, overrides);
+    if ('error' in merged) {
+        return { status: 400, error: merged.error, suggestion };
+    }
+    const duplicate = classifyProjectMemorySuggestionDuplicate({
+        suggestion: {
+            kind: 'decision',
+            title: merged.values.title ?? '',
+            scope: merged.values.scope ?? null,
+            decision: merged.values.decision ?? '',
+            rationale: merged.values.rationale ?? null,
+            implications: parseStringArray(merged.values.implications_json ?? null),
+        },
+        activeConventions: [],
+        activeDecisions: listProjectDecisions(projectId).filter(decision => decision.id !== decisionId),
+        pendingSuggestions: listProjectMemorySuggestionRows(projectId, { status: 'pending' })
+            .filter(row => row.id !== suggestionId)
+            .map(toProjectMemorySuggestionCandidate)
+            .filter((candidate) => candidate !== null),
+    });
+    if (duplicate?.action === 'suppress' && duplicate.target === 'decision') {
+        return { status: 409, error: 'Updating this decision would duplicate another accepted decision', suggestion };
+    }
+    const updatedDecision = updateProjectDecision(projectId, decisionId, {
+        title: merged.values.title ?? existingDecision.title,
+        scope: merged.values.scope ?? null,
+        decision: merged.values.decision ?? existingDecision.decision,
+        rationale: merged.values.rationale ?? null,
+        implications_json: merged.values.implications_json ?? (existingDecision.implications.length > 0 ? JSON.stringify(existingDecision.implications) : null),
+    });
+    if (!updatedDecision) {
+        return { status: 500, error: 'Unable to update the existing decision', suggestion };
+    }
+    const updatedSuggestion = updateProjectMemorySuggestionStatus(projectId, suggestionId, 'applied_to_existing', updatedDecision.id);
+    if (!updatedSuggestion) {
+        return { status: 500, error: 'Unable to update the suggestion state', suggestion };
+    }
+    return {
+        suggestion: updatedSuggestion,
+        decision: updatedDecision,
+    };
+};
+//# sourceMappingURL=projectMemory.js.map