@psnext/lscg 0.1.4 → 0.1.6

package/dist/src/storage/explore-queries.js

@@ -0,0 +1,184 @@
+import { DatabaseSync } from 'node:sqlite';
+import { parseMetadata, parsePoint } from './row-decoders.js';
+const EXPLORE_KINDS = ['contains', 'defines', 'calls', 'imports', 'exports'];
+export function selectExploreAggregates(db, repositoryId, search) {
+    const predicates = ['f.repository_id = ?'];
+    const params = [repositoryId];
+    if (search?.trim()) {
+        predicates.push('(lower(f.path) LIKE ? OR lower(f.path) = ?)');
+        const normalized = search.trim().toLocaleLowerCase();
+        params.push(`%${normalized}%`, normalized);
+    }
+    const rows = db.prepare(`
+    SELECT f.id, f.path, f.language, f.repository_id AS repositoryId,
+      (SELECT count(*) FROM nodes n WHERE n.repository_id = f.repository_id AND n.file_id = f.id) AS childCount
+    FROM files f
+    WHERE ${predicates.join(' AND ')}
+    ORDER BY lower(f.path), f.id
+  `).all(...params);
+    return rows.map((row) => ({ ...row, id: aggregateId(repositoryId, row.id), childCount: Number(row.childCount) }));
+}
+export function selectExploreAggregateEdges(db, repositoryId, kinds = EXPLORE_KINDS) {
+    const safeKinds = kinds.filter((kind) => EXPLORE_KINDS.includes(kind));
+    if (safeKinds.length === 0)
+        return [];
+    const placeholders = safeKinds.map(() => '?').join(', ');
+    const rows = db.prepare(`
+    SELECT MIN(e.id) AS id, e.kind,
+      'aggregate:' || e.repository_id || ':' || sf.id AS sourceAggregateId,
+      'aggregate:' || e.repository_id || ':' || tf.id AS targetAggregateId,
+      AVG(e.confidence) AS confidence, count(*) AS count
+    FROM edges e
+    JOIN nodes s ON s.id = e.source_id AND s.repository_id = e.repository_id
+    JOIN nodes t ON t.id = e.target_id AND t.repository_id = e.repository_id
+    LEFT JOIN files sf ON sf.id = s.file_id
+    LEFT JOIN files tf ON tf.id = t.file_id
+    WHERE e.repository_id = ? AND e.kind IN (${placeholders}) AND sf.id IS NOT NULL AND tf.id IS NOT NULL AND sf.id <> tf.id
+    GROUP BY sf.id, tf.id, e.kind
+    ORDER BY sourceAggregateId, targetAggregateId, e.kind
+  `).all(repositoryId, ...safeKinds);
+    return rows.map((row) => ({
+        id: String(row.id), sourceId: String(row.sourceAggregateId), targetId: String(row.targetAggregateId),
+        sourceAggregateId: String(row.sourceAggregateId), targetAggregateId: String(row.targetAggregateId),
+        kind: row.kind, confidence: Number(row.confidence ?? 0), count: Number(row.count ?? 0), metadata: {}
+    }));
+}
+export function selectExploreSourcesForSearch(db, repositoryId, term, limit = 200) {
+    const normalized = term.trim().toLocaleLowerCase();
+    if (!normalized)
+        return [];
+    const rows = db.prepare(`
+    SELECT n.id, n.kind, n.type, n.name, n.file_id AS fileId,
+      n.start_point AS startPoint, n.end_point AS endPoint, n.metadata_json AS metadataJson, f.path AS path
+    FROM nodes n LEFT JOIN files f ON f.id = n.file_id
+    WHERE n.repository_id = ? AND (
+      lower(COALESCE(n.name, '')) = ? OR
+      lower(COALESCE(f.path, '') || ':' || COALESCE(n.name, '')) = ? OR
+      lower(COALESCE(n.name, '')) LIKE ? OR
+      lower(COALESCE(n.name, '')) LIKE ?
+    )
+    ORDER BY CASE
+      WHEN lower(COALESCE(f.path, '') || ':' || COALESCE(n.name, '')) = ? THEN 0
+      WHEN lower(COALESCE(n.name, '')) = ? THEN 1
+      WHEN lower(COALESCE(n.name, '')) LIKE ? THEN 2 ELSE 3 END,
+      lower(COALESCE(f.path, '')), lower(COALESCE(n.name, '')), n.id
+    LIMIT ?
+  `).all(repositoryId, normalized, normalized, `${normalized}%`, `%${normalized}%`, normalized, normalized, `${normalized}%`, Math.max(1, Math.min(1000, limit)));
+    return rows.map(sourceFromRow);
+}
+export function selectExploreCandidates(db, repositoryId, term, { kind, file, fileAnchor = false, limit = 20 } = {}) {
+    const normalized = term.trim().toLocaleLowerCase();
+    if (!normalized)
+        return [];
+    const safeLimit = Math.max(1, Math.min(100, Math.trunc(limit)));
+    const explicitFiles = db.prepare('SELECT id, path FROM files WHERE repository_id = ? AND path = ? ORDER BY id LIMIT ?').all(repositoryId, term.trim(), safeLimit);
+    if (fileAnchor && explicitFiles.length > 0)
+        return explicitFiles.map((row, index) => {
+            const fileId = String(row.id);
+            const filePath = String(row.path);
+            return { id: aggregateId(repositoryId, fileId), kind: 'file', type: 'file', name: filePath, fileId, path: filePath, startPoint: { row: 0, column: 0 }, endPoint: { row: 0, column: 0 }, metadata: {}, rank: index, match: 'path', qualifiedName: filePath, aggregateId: aggregateId(repositoryId, fileId) };
+        });
+    const stages = [
+        { match: 'exact', predicate: 'lower(COALESCE(n.name, \'\')) = ?', params: [normalized] },
+        { match: 'qualified', predicate: "lower(COALESCE(f.path, '') || ':' || COALESCE(n.name, '')) = ?", params: [normalized] },
+        { match: 'prefix', predicate: 'lower(COALESCE(n.name, \'\')) LIKE ?', params: [`${normalized}%`] },
+        { match: 'substring', predicate: 'lower(COALESCE(n.name, \'\')) LIKE ?', params: [`%${normalized}%`] }
+    ];
+    const result = [];
+    const seen = new Set();
+    for (const stage of stages) {
+        const predicates = ['n.repository_id = ?', stage.predicate];
+        const params = [repositoryId, ...stage.params];
+        if (kind) {
+            predicates.push('n.kind = ?');
+            params.push(kind);
+        }
+        if (file) {
+            predicates.push('f.path = ?');
+            params.push(file);
+        }
+        const rows = db.prepare(`
+      SELECT n.id, n.kind, n.type, n.name, n.file_id AS fileId,
+        n.start_point AS startPoint, n.end_point AS endPoint, n.metadata_json AS metadataJson, f.path AS path
+      FROM nodes n LEFT JOIN files f ON f.id = n.file_id
+      WHERE ${predicates.join(' AND ')}
+      ORDER BY lower(COALESCE(f.path, '')), lower(COALESCE(n.name, '')), n.id LIMIT ?
+    `).all(...params, safeLimit);
+        for (const row of rows) {
+            const source = sourceFromRow(row);
+            if (seen.has(source.id))
+                continue;
+            seen.add(source.id);
+            result.push({ ...source, rank: result.length, match: stage.match, qualifiedName: qualifiedName(source), aggregateId: source.fileId ? aggregateId(repositoryId, source.fileId) : null });
+        }
+        if (result.length > 0)
+            break;
+    }
+    // A path is an explicit file identity and resolves to its aggregate.
+    for (const row of explicitFiles) {
+        const fileId = String(row.id);
+        const id = aggregateId(repositoryId, fileId);
+        if (seen.has(id))
+            continue;
+        result.push({ id, kind: 'file', type: 'file', name: String(row.path), fileId, path: String(row.path), startPoint: { row: 0, column: 0 }, endPoint: { row: 0, column: 0 }, metadata: {}, rank: result.length, match: 'path', qualifiedName: String(row.path), aggregateId: id });
+    }
+    return result.slice(0, safeLimit);
+}
+export function selectExploreNode(db, repositoryId, id) {
+    const row = db.prepare(`
+    SELECT n.id, n.kind, n.type, n.name, n.file_id AS fileId,
+      n.start_point AS startPoint, n.end_point AS endPoint, n.metadata_json AS metadataJson, f.path AS path
+    FROM nodes n LEFT JOIN files f ON f.id = n.file_id WHERE n.repository_id = ? AND n.id = ?
+  `).get(repositoryId, id);
+    return row ? sourceFromRow(row) : null;
+}
+export function selectExploreTraversalEdges(db, repositoryId, frontier, direction, kinds, limit) {
+    if (frontier.length === 0 || limit <= 0)
+        return [];
+    const safeKinds = kinds.filter((kind) => EXPLORE_KINDS.includes(kind));
+    if (safeKinds.length === 0)
+        return [];
+    const nodePlaceholders = frontier.map(() => '?').join(', ');
+    const kindPlaceholders = safeKinds.map(() => '?').join(', ');
+    const adjacency = direction === 'incoming'
+        ? `(e.target_id IN (${nodePlaceholders}))`
+        : direction === 'outgoing'
+            ? `(e.source_id IN (${nodePlaceholders}))`
+            : `(e.source_id IN (${nodePlaceholders}) OR e.target_id IN (${nodePlaceholders}))`;
+    const nodeParams = direction === 'both' ? [...frontier, ...frontier] : [...frontier];
+    const rows = db.prepare(`
+    SELECT e.id, e.source_id AS sourceId, e.target_id AS targetId, e.kind, e.confidence, e.metadata_json AS metadataJson
+    FROM edges e
+    WHERE e.repository_id = ? AND e.kind IN (${kindPlaceholders}) AND ${adjacency}
+    ORDER BY e.kind, e.id
+    LIMIT ?
+  `).all(repositoryId, ...safeKinds, ...nodeParams, Math.max(1, limit));
+    return rows.map((row) => ({ id: String(row.id), sourceId: String(row.sourceId), targetId: String(row.targetId), kind: row.kind, confidence: Number(row.confidence ?? 0), metadata: parseMetadata(row.metadataJson) }));
+}
+export function selectExploreNodeRows(db, repositoryId, ids) {
+    if (ids.length === 0)
+        return [];
+    const placeholders = ids.map(() => '?').join(', ');
+    const rows = db.prepare(`
+    SELECT n.id, n.kind, n.type, n.name, n.file_id AS fileId,
+      n.start_point AS startPoint, n.end_point AS endPoint, n.metadata_json AS metadataJson, f.path AS path
+    FROM nodes n LEFT JOIN files f ON f.id = n.file_id
+    WHERE n.repository_id = ? AND n.id IN (${placeholders})
+  `).all(repositoryId, ...ids);
+    const byId = new Map(rows.map((row) => [String(row.id), sourceFromRow(row)]));
+    return ids.flatMap((id) => byId.get(id) ? [byId.get(id)] : []);
+}
+export function aggregateId(repositoryId, fileId) {
+    return `aggregate:${repositoryId}:${fileId}`;
+}
+function sourceFromRow(row) {
+    return {
+        id: String(row.id), kind: row.kind, type: String(row.type), name: row.name == null ? null : String(row.name),
+        fileId: row.fileId == null ? null : String(row.fileId), path: row.path == null ? null : String(row.path),
+        startPoint: parsePoint(row.startPoint), endPoint: parsePoint(row.endPoint), metadata: parseMetadata(row.metadataJson)
+    };
+}
+function qualifiedName(source) {
+    return source.name && source.path ? `${source.path}:${source.name}` : source.name;
+}
+//# sourceMappingURL=explore-queries.js.map

package/dist/src/storage/graph-writes.d.ts

@@ -1,16 +1,35 @@
 import { DatabaseSync } from 'node:sqlite';
-import type { FileAttribution, FileRecord, GraphEdge, GraphNode, RepositoryRecord } from '../types.js';
+import type { AttributionApplyResult, AttributionOutcome, FileRecord, GraphEdge, GraphNode, RepositoryRecord } from '../types.js';
 export declare function upsertRepository(db: DatabaseSync, repository: RepositoryRecord): void;
-export declare function replaceFileGraph(db: DatabaseSync, { repository, file, nodes, edges, attribution }: {
+export declare function replaceFileGraph(db: DatabaseSync, { repository, file, nodes, edges, enrichment }: {
     repository: RepositoryRecord;
     file: FileRecord;
     nodes: GraphNode[];
     edges: GraphEdge[];
-    attribution?: FileAttribution | null;
+    enrichment?: {
+        pluginName: string;
+        historyFingerprint: string | null;
+    };
 }): void;
+/**
+ * Applies optional attribution only when it still matches the structural file
+ * hash. Failed outcomes never mutate existing attribution.
+ */
+export declare function applyFileAttribution(db: DatabaseSync, { repository, fileId, sourceHash, outcome, pluginName, historyFingerprint }: {
+    repository: RepositoryRecord;
+    fileId: string;
+    sourceHash: string;
+    outcome: AttributionOutcome;
+    pluginName?: string;
+    historyFingerprint?: string | null;
+}): AttributionApplyResult;
 export declare function reconcileDeletedFiles(db: DatabaseSync, repositoryId: string, discoveredPaths: string[]): void;
+export declare function recordFileScanFailure(db: DatabaseSync, repositoryId: string, filePath: string, diagnostic: string): void;
+export declare function clearFileScanFailure(db: DatabaseSync, repositoryId: string, filePath: string): void;
+export declare function setRepositoryScanState(db: DatabaseSync, repositoryId: string, state: 'fresh' | 'degraded' | 'stale'): void;
 export declare function selectFileInventory(db: DatabaseSync, repositoryId: string): Array<{
     path: string;
+    hash: string;
     size: number;
     mtimeMs: number;
 }>;

package/dist/src/storage/graph-writes.js

@@ -10,13 +10,14 @@ export function upsertRepository(db, repository) {
       updated_at = datetime('now')
   `).run(repository.id, repository.root, repository.name);
 }
-export function replaceFileGraph(db, { repository, file, nodes, edges, attribution }) {
+export function replaceFileGraph(db, { repository, file, nodes, edges, enrichment }) {
     upsertRepository(db, repository);
     db.exec('BEGIN IMMEDIATE');
     try {
-        if (attribution) {
-            upsertContributorNodes(db, repository, attribution.contributorEmails);
-        }
+        // The structural replacement must not depend on Git attribution. Preserve
+        // attribution for structurally stable nodes so a later failed enrichment
+        // does not make previously successful data disappear.
+        const priorAttribution = captureFileAttribution(db, file.id);
         db.prepare('DELETE FROM edges WHERE file_id = ?').run(file.id);
         db.prepare('DELETE FROM nodes WHERE file_id = ?').run(file.id);
         db.prepare(`
@@ -36,30 +37,62 @@ export function replaceFileGraph(db, { repository, file, nodes, edges, attributi
         start_point, end_point, source_hash, parser, parser_version, metadata_json, last_modified_user_id
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
-        const attributionByNodeId = new Map(attribution?.nodeAttributions.map((entry) => [entry.nodeId, entry]) ?? []);
         for (const node of nodes) {
-            const nodeAttribution = attributionByNodeId.get(node.id);
-            insertNode.run(node.id, repository.id, file.id, node.kind, node.type, node.name ?? null, node.startByte, node.endByte, JSON.stringify(node.startPoint), JSON.stringify(node.endPoint), node.sourceHash, node.parser, node.parserVersion, JSON.stringify(node.metadata ?? {}), node.lastModifiedUserId ?? resolveUserId(repository, nodeAttribution?.lastModifiedEmail ?? null));
+            insertNode.run(node.id, repository.id, file.id, node.kind, node.type, node.name ?? null, node.startByte, node.endByte, JSON.stringify(node.startPoint), JSON.stringify(node.endPoint), node.sourceHash, node.parser, node.parserVersion, JSON.stringify(node.metadata ?? {}), null);
         }
         const insertEdge = db.prepare(`
       INSERT INTO edges(
-        id, repository_id, file_id, source_id, target_id, kind, confidence, metadata_json
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        id, repository_id, file_id, source_id, target_id, kind, type, confidence, metadata_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
         for (const edge of edges) {
-            insertEdge.run(edge.id, repository.id, file.id, edge.sourceId, edge.targetId, edge.kind, edge.confidence ?? 1, JSON.stringify(edge.metadata ?? {}));
+            insertEdge.run(edge.id, repository.id, file.id, edge.sourceId, edge.targetId, edge.kind, edge.type ?? edge.kind, edge.confidence ?? 1, JSON.stringify(edge.metadata ?? {}));
         }
-        if (attribution) {
-            for (const entry of attribution.nodeAttributions) {
-                for (const email of entry.contributorEmails) {
-                    const contributorId = resolveUserId(repository, email);
-                    if (!contributorId)
-                        continue;
-                    insertEdge.run(hashParts([repository.id, file.id, entry.nodeId, contributorId, 'attributed_to']), repository.id, file.id, entry.nodeId, contributorId, 'attributed_to', 1, JSON.stringify({ email }));
-                }
-            }
+        restorePriorAttribution(db, file.id, new Set(nodes.map((node) => node.id)), priorAttribution);
+        if (enrichment)
+            queueFileEnrichment(db, repository.id, file.id, file.hash, enrichment.pluginName, enrichment.historyFingerprint);
+        db.exec('COMMIT');
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+    }
+}
+/**
+ * Applies optional attribution only when it still matches the structural file
+ * hash. Failed outcomes never mutate existing attribution.
+ */
+export function applyFileAttribution(db, { repository, fileId, sourceHash, outcome, pluginName = 'git-attribution-plugin', historyFingerprint = null }) {
+    db.exec('BEGIN IMMEDIATE');
+    try {
+        const current = db.prepare(`
+        SELECT f.hash AS sourceHash, e.source_hash AS enrichmentHash,
+          e.plugin_name AS pluginName, e.history_fingerprint AS historyFingerprint
+        FROM files f LEFT JOIN file_enrichment_state e ON e.file_id = f.id
+        WHERE f.id = ? AND f.repository_id = ?
+      `).get(fileId, repository.id);
+        if (current?.sourceHash === sourceHash && current.enrichmentHash === undefined) {
+            queueFileEnrichment(db, repository.id, fileId, sourceHash, pluginName, historyFingerprint);
+        }
+        const refreshed = current?.enrichmentHash === undefined
+            ? { ...current, enrichmentHash: sourceHash, pluginName, historyFingerprint }
+            : current;
+        if (refreshed?.sourceHash !== sourceHash || refreshed.enrichmentHash !== sourceHash || refreshed.pluginName !== pluginName || refreshed.historyFingerprint !== historyFingerprint) {
+            db.exec('ROLLBACK');
+            return 'stale';
+        }
+        if (outcome.status === 'complete') {
+            replaceAttribution(db, repository, fileId, outcome.attribution);
+            setFileEnrichmentState(db, repository.id, fileId, 'complete', 'complete', null);
+        }
+        else if (outcome.status === 'unavailable') {
+            setFileEnrichmentState(db, repository.id, fileId, 'complete', 'unavailable', `unavailable:${outcome.reason}`);
+        }
+        else {
+            setFileEnrichmentState(db, repository.id, fileId, 'failed', 'failed', outcome.diagnostic);
         }
         db.exec('COMMIT');
+        return 'applied';
     }
     catch (error) {
         db.exec('ROLLBACK');
@@ -75,6 +108,8 @@ export function reconcileDeletedFiles(db, repositoryId, discoveredPaths) {
             if (!keep.has(row.path))
                 db.prepare('DELETE FROM files WHERE repository_id = ? AND path = ?').run(repositoryId, row.path);
         }
+        db.prepare(`DELETE FROM file_scan_failures WHERE repository_id = ? AND path NOT IN (SELECT value FROM json_each(?))`)
+            .run(repositoryId, JSON.stringify(discoveredPaths));
         db.exec('COMMIT');
     }
     catch (error) {
@@ -82,8 +117,120 @@ export function reconcileDeletedFiles(db, repositoryId, discoveredPaths) {
         throw error;
     }
 }
+export function recordFileScanFailure(db, repositoryId, filePath, diagnostic) {
+    db.prepare(`
+    INSERT INTO file_scan_failures(repository_id, path, diagnostic, failed_at)
+    VALUES (?, ?, ?, datetime('now'))
+    ON CONFLICT(repository_id, path) DO UPDATE SET
+      diagnostic = excluded.diagnostic,
+      failed_at = datetime('now')
+  `).run(repositoryId, filePath, diagnostic);
+}
+export function clearFileScanFailure(db, repositoryId, filePath) {
+    db.prepare('DELETE FROM file_scan_failures WHERE repository_id = ? AND path = ?').run(repositoryId, filePath);
+}
+export function setRepositoryScanState(db, repositoryId, state) {
+    db.prepare(`
+    INSERT INTO repository_scan_state(repository_id, state, updated_at)
+    VALUES (?, ?, datetime('now'))
+    ON CONFLICT(repository_id) DO UPDATE SET
+      state = excluded.state,
+      updated_at = datetime('now')
+  `).run(repositoryId, state);
+}
 export function selectFileInventory(db, repositoryId) {
-    return db.prepare('SELECT path, size, mtime_ms AS mtimeMs FROM files WHERE repository_id = ? ORDER BY path').all(repositoryId);
+    return db.prepare('SELECT path, hash, size, mtime_ms AS mtimeMs FROM files WHERE repository_id = ? ORDER BY path').all(repositoryId);
+}
+function captureFileAttribution(db, fileId) {
+    return {
+        lastModified: db.prepare(`
+      SELECT id AS nodeId, last_modified_user_id AS userId,
+        kind || ':' || type || ':' || COALESCE(name, '') AS key
+      FROM nodes
+      WHERE file_id = ? AND last_modified_user_id IS NOT NULL
+    `).all(fileId),
+        edges: db.prepare(`
+      SELECT e.id, e.source_id AS sourceId,
+        n.kind || ':' || n.type || ':' || COALESCE(n.name, '') AS sourceKey,
+        e.target_id AS targetId, e.confidence, e.metadata_json AS metadataJson
+      FROM edges e JOIN nodes n ON n.id = e.source_id
+      WHERE e.file_id = ? AND e.kind = 'attributed_to'
+    `).all(fileId)
+    };
+}
+function restorePriorAttribution(db, fileId, currentNodeIds, prior) {
+    const currentByKey = new Map(db.prepare(`
+    SELECT id, kind || ':' || type || ':' || COALESCE(name, '') AS key
+    FROM nodes WHERE file_id = ?
+  `).all(fileId).map((row) => [row.key, row.id]));
+    const mappedNodeId = (nodeId, key) => currentNodeIds.has(nodeId) ? nodeId : currentByKey.get(key);
+    const updateLastModified = db.prepare('UPDATE nodes SET last_modified_user_id = ? WHERE id = ? AND file_id = ?');
+    for (const entry of prior.lastModified) {
+        const currentId = mappedNodeId(entry.nodeId, entry.key);
+        if (currentId)
+            updateLastModified.run(entry.userId, currentId, fileId);
+    }
+    const insertEdge = db.prepare(`
+    INSERT OR IGNORE INTO edges(id, repository_id, file_id, source_id, target_id, kind, type, confidence, metadata_json)
+    SELECT ?, repository_id, ?, ?, ?, 'attributed_to', 'attributed_to', ?, ?
+    FROM files WHERE id = ?
+  `);
+    for (const edge of prior.edges) {
+        const currentSourceId = mappedNodeId(edge.sourceId, edge.sourceKey);
+        if (currentSourceId) {
+            const edgeId = currentSourceId === edge.sourceId ? edge.id : hashParts([fileId, currentSourceId, edge.targetId, 'attributed_to']);
+            insertEdge.run(edgeId, fileId, currentSourceId, edge.targetId, edge.confidence, edge.metadataJson, fileId);
+        }
+    }
+}
+function queueFileEnrichment(db, repositoryId, fileId, sourceHash, pluginName, historyFingerprint) {
+    db.prepare(`
+    INSERT INTO file_enrichment_state(
+      repository_id, file_id, plugin_name, source_hash, history_fingerprint, state, outcome, diagnostic, queued_at, updated_at, completed_at, failed_at
+    ) VALUES (?, ?, ?, ?, ?, 'pending', NULL, NULL, datetime('now'), datetime('now'), NULL, NULL)
+    ON CONFLICT(file_id) DO UPDATE SET
+      repository_id = excluded.repository_id,
+      plugin_name = excluded.plugin_name,
+      source_hash = excluded.source_hash,
+      history_fingerprint = excluded.history_fingerprint,
+      state = 'pending',
+      outcome = NULL,
+      diagnostic = NULL,
+      queued_at = datetime('now'),
+      updated_at = datetime('now'),
+      completed_at = NULL,
+      failed_at = NULL
+  `).run(repositoryId, fileId, pluginName, sourceHash, historyFingerprint);
+}
+function replaceAttribution(db, repository, fileId, attribution) {
+    upsertContributorNodes(db, repository, attribution.contributorEmails);
+    db.prepare("DELETE FROM edges WHERE file_id = ? AND kind = 'attributed_to'").run(fileId);
+    db.prepare('UPDATE nodes SET last_modified_user_id = NULL WHERE file_id = ?').run(fileId);
+    const updateLastModified = db.prepare('UPDATE nodes SET last_modified_user_id = ? WHERE id = ? AND file_id = ?');
+    const insertEdge = db.prepare(`
+    INSERT INTO edges(id, repository_id, file_id, source_id, target_id, kind, type, confidence, metadata_json)
+    VALUES (?, ?, ?, ?, ?, 'attributed_to', 'attributed_to', 1, ?)
+  `);
+    for (const entry of attribution.nodeAttributions) {
+        const lastModifiedUserId = resolveUserId(repository, entry.lastModifiedEmail);
+        if (lastModifiedUserId)
+            updateLastModified.run(lastModifiedUserId, entry.nodeId, fileId);
+        for (const email of entry.contributorEmails) {
+            const contributorId = resolveUserId(repository, email);
+            if (!contributorId)
+                continue;
+            insertEdge.run(hashParts([repository.id, fileId, entry.nodeId, contributorId, 'attributed_to']), repository.id, fileId, entry.nodeId, contributorId, JSON.stringify({ email: normalizeEmail(email) }));
+        }
+    }
+}
+function setFileEnrichmentState(db, repositoryId, fileId, state, outcome, diagnostic) {
+    db.prepare(`
+    UPDATE file_enrichment_state
+    SET state = ?, outcome = ?, diagnostic = ?, updated_at = datetime('now'),
+      completed_at = CASE WHEN ? = 'complete' THEN datetime('now') ELSE NULL END,
+      failed_at = CASE WHEN ? = 'failed' THEN datetime('now') ELSE NULL END
+    WHERE repository_id = ? AND file_id = ?
+  `).run(state, outcome, diagnostic, state, state, repositoryId, fileId);
 }
 function upsertContributorNodes(db, repository, contributorEmails) {
     const insertNode = db.prepare(`

package/dist/src/storage/manifest-inventory.d.ts

@@ -0,0 +1,23 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { ManifestKind, ManifestStatus, RepositoryManifest } from '../scanner/artifactInventory.js';
+export interface RepositoryManifestInventoryRow {
+    repositoryId: string;
+    path: string;
+    kind: ManifestKind;
+    moduleIdentity: string;
+    status: ManifestStatus;
+    size: number;
+    mtimeMs: number;
+    sourceHash: string | null;
+    generation: number;
+}
+export declare function selectManifestInventory(db: DatabaseSync, repositoryId: string): RepositoryManifestInventoryRow[];
+/** Persist one complete inventory snapshot. Uncertain records remain queryable for restart-safe retention. */
+export declare function persistManifestInventory(db: DatabaseSync, repositoryId: string, manifests: readonly RepositoryManifest[], generation: number): void;
+/** Persist inventory and freshness together at the end of a structural scan. */
+export declare function persistManifestInventoryAndScanState(db: DatabaseSync, repositoryId: string, manifests: readonly RepositoryManifest[], generation: number, state: 'fresh' | 'degraded' | 'stale'): void;
+/** Descriptive aliases for callers that prefer the table's full name. */
+export declare const selectRepositoryManifestInventory: typeof selectManifestInventory;
+export declare const persistRepositoryManifestInventory: typeof persistManifestInventory;
+export declare function manifestRowsAsRecords(rows: readonly RepositoryManifestInventoryRow[]): RepositoryManifest[];
+//# sourceMappingURL=manifest-inventory.d.ts.map

package/dist/src/storage/manifest-inventory.js

@@ -0,0 +1,82 @@
+export function selectManifestInventory(db, repositoryId) {
+    const rows = db.prepare(`
+    SELECT repository_id AS repositoryId, path, kind, module_identity AS moduleIdentity,
+      status, size, mtime_ms AS mtimeMs, source_hash AS sourceHash, generation
+    FROM repository_manifest_inventory
+    WHERE repository_id = ?
+    ORDER BY path
+  `).all(repositoryId);
+    return rows.map((row) => ({
+        repositoryId: String(row.repositoryId),
+        path: String(row.path),
+        kind: row.kind,
+        moduleIdentity: String(row.moduleIdentity),
+        status: row.status,
+        size: Number(row.size),
+        mtimeMs: Number(row.mtimeMs),
+        sourceHash: typeof row.sourceHash === 'string' ? row.sourceHash : null,
+        generation: Number(row.generation)
+    }));
+}
+/** Persist one complete inventory snapshot. Uncertain records remain queryable for restart-safe retention. */
+export function persistManifestInventory(db, repositoryId, manifests, generation) {
+    inTransaction(db, () => writeManifestInventory(db, repositoryId, manifests, generation));
+}
+/** Persist inventory and freshness together at the end of a structural scan. */
+export function persistManifestInventoryAndScanState(db, repositoryId, manifests, generation, state) {
+    inTransaction(db, () => {
+        writeManifestInventory(db, repositoryId, manifests, generation);
+        db.prepare(`
+      INSERT INTO repository_scan_state(repository_id, state, updated_at)
+      VALUES (?, ?, datetime('now'))
+      ON CONFLICT(repository_id) DO UPDATE SET state = excluded.state, updated_at = excluded.updated_at
+    `).run(repositoryId, state);
+    });
+}
+function writeManifestInventory(db, repositoryId, manifests, generation) {
+    const statement = db.prepare(`
+    INSERT INTO repository_manifest_inventory(
+      repository_id, path, kind, module_identity, status, size, mtime_ms, source_hash, generation
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(repository_id, path) DO UPDATE SET
+      kind = excluded.kind,
+      module_identity = excluded.module_identity,
+      status = excluded.status,
+      size = excluded.size,
+      mtime_ms = excluded.mtime_ms,
+      source_hash = excluded.source_hash,
+      generation = excluded.generation,
+      updated_at = datetime('now')
+  `);
+    for (const manifest of manifests) {
+        statement.run(repositoryId, manifest.path, manifest.kind, manifest.moduleIdentity, manifest.status, manifest.size, manifest.mtimeMs, manifest.sourceHash, generation);
+    }
+}
+function inTransaction(db, work) {
+    db.exec('BEGIN IMMEDIATE');
+    try {
+        work();
+        db.exec('COMMIT');
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+    }
+}
+/** Descriptive aliases for callers that prefer the table's full name. */
+export const selectRepositoryManifestInventory = selectManifestInventory;
+export const persistRepositoryManifestInventory = persistManifestInventory;
+export function manifestRowsAsRecords(rows) {
+    return rows.map((row) => ({
+        path: row.path,
+        kind: row.kind,
+        moduleIdentity: row.moduleIdentity,
+        size: row.size,
+        mtimeMs: row.mtimeMs,
+        sourceHash: row.sourceHash,
+        content: null,
+        status: row.status,
+        generation: row.generation
+    }));
+}
+//# sourceMappingURL=manifest-inventory.js.map

package/dist/src/storage/plugin-graph.js

@@ -13,8 +13,8 @@ export function reconcilePluginEdges(db, repository, edges, fileIdByPath, active
       `).run(repository.id, plugin);
         }
         const insert = db.prepare(`
-      INSERT OR REPLACE INTO edges(id, repository_id, file_id, source_id, target_id, kind, confidence, metadata_json)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT OR REPLACE INTO edges(id, repository_id, file_id, source_id, target_id, kind, type, confidence, metadata_json)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
         for (const edge of edges) {
             const plugin = typeof edge.metadata.plugin === 'string' ? edge.metadata.plugin : undefined;
@@ -29,7 +29,7 @@ export function reconcilePluginEdges(db, repository, edges, fileIdByPath, active
             const requiredEndpoints = edge.sourceId === edge.targetId ? 1 : 2;
             if (endpoints.count !== requiredEndpoints)
                 continue;
-            insert.run(edge.id, repository.id, fileId, edge.sourceId, edge.targetId, edge.kind, edge.confidence ?? 1, JSON.stringify(edge.metadata ?? {}));
+            insert.run(edge.id, repository.id, fileId, edge.sourceId, edge.targetId, edge.kind, edge.type ?? edge.kind, edge.confidence ?? 1, JSON.stringify(edge.metadata ?? {}));
             inserted += 1;
         }
         db.exec('COMMIT');

package/dist/src/storage/queries.d.ts

@@ -1,5 +1,10 @@
 import { DatabaseSync } from 'node:sqlite';
-import type { GraphEdgeRow, GraphNodeRow, GraphNodeTextRow, StatusResult } from '../types.js';
+import type { EnrichmentState, EnrichmentSummary, EnrichmentWork, FileEnrichmentState, FreshnessReport, GraphEdgeRow, GraphNodeRow, GraphNodeTextRow, StatusResult } from '../types.js';
+export declare function selectFreshnessReport(db: DatabaseSync, repositoryId: string): FreshnessReport;
+export declare function selectFileEnrichmentState(db: DatabaseSync, repositoryId: string, fileId: string): FileEnrichmentState | null;
+export declare function selectFileEnrichmentStates(db: DatabaseSync, repositoryId: string, states?: readonly EnrichmentState[]): FileEnrichmentState[];
+export declare function selectEnrichmentWork(db: DatabaseSync, repositoryId: string, states?: readonly EnrichmentState[]): EnrichmentWork[];
+export declare function selectEnrichmentSummary(db: DatabaseSync, repositoryId: string): EnrichmentSummary;
 export declare function getStatus(db: DatabaseSync, repositoryId: string): StatusResult;
 export declare function selectNodes(db: DatabaseSync, repositoryId: string, { kind, limit }?: {
     kind?: string | undefined;
@@ -14,12 +19,14 @@ export declare function selectAllNodeTextRows(db: DatabaseSync, repositoryId: st
 export declare function selectAllNodes(db: DatabaseSync, repositoryId: string, { kind }?: {
     kind?: string | undefined;
 }): GraphNodeRow[];
-export declare function selectEdges(db: DatabaseSync, repositoryId: string, { kind, limit }?: {
+export declare function selectEdges(db: DatabaseSync, repositoryId: string, { kind, type, limit }?: {
     kind?: string | undefined;
+    type?: string | undefined;
     limit?: number | undefined;
 }): GraphEdgeRow[];
-export declare function selectAllEdges(db: DatabaseSync, repositoryId: string, { kind }?: {
+export declare function selectAllEdges(db: DatabaseSync, repositoryId: string, { kind, type }?: {
     kind?: string | undefined;
+    type?: string | undefined;
 }): GraphEdgeRow[];
 export declare function clampLimit(limit: number | undefined, max?: number): number;
 //# sourceMappingURL=queries.d.ts.map