sdl-mcp 0.9.2 → 0.9.3

package/dist/db/ladybug-edges.js

@@ -40,18 +40,18 @@ export async function insertEdge(conn, edge) {
     // and SYMBOL_IN_REPO edge when the target hasn't been indexed yet. This is
     // intentional — stubs are populated when the target file is indexed, and
     // queries that need full symbol data filter via SYMBOL_IN_FILE joins.
-    await exec(conn, `MATCH (r:Repo {repoId: $repoId})
-     MERGE (a:Symbol {symbolId: $fromSymbolId})
-     MERGE (b:Symbol {symbolId: $toSymbolId})
-     MERGE (a)-[:SYMBOL_IN_REPO]->(r)
-     MERGE (b)-[:SYMBOL_IN_REPO]->(r)
-     MERGE (a)-[d:DEPENDS_ON {edgeType: $edgeType}]->(b)
-     SET d.weight = $weight,
-         d.confidence = $confidence,
-         d.resolution = $resolution,
-         d.resolverId = $resolverId,
-         d.resolutionPhase = $resolutionPhase,
-         d.provenance = $provenance,
+    await exec(conn, `MATCH (r:Repo {repoId: $repoId})
+     MERGE (a:Symbol {symbolId: $fromSymbolId})
+     MERGE (b:Symbol {symbolId: $toSymbolId})
+     MERGE (a)-[:SYMBOL_IN_REPO]->(r)
+     MERGE (b)-[:SYMBOL_IN_REPO]->(r)
+     MERGE (a)-[d:DEPENDS_ON {edgeType: $edgeType}]->(b)
+     SET d.weight = $weight,
+         d.confidence = $confidence,
+         d.resolution = $resolution,
+         d.resolverId = $resolverId,
+         d.resolutionPhase = $resolutionPhase,
+         d.provenance = $provenance,
          d.createdAt = $createdAt`, {
         repoId: edge.repoId,
         fromSymbolId: edge.fromSymbolId,
@@ -81,20 +81,20 @@ export async function insertEdges(conn, edges) {
         for (const [repoId, repoEdges] of edgesByRepo) {
             const fromSymbolIds = [...new Set(repoEdges.map((e) => e.fromSymbolId))];
             for (const symbolId of fromSymbolIds) {
-                await exec(txConn, `MATCH (r:Repo {repoId: $repoId})
-           MERGE (s:Symbol {symbolId: $symbolId})
+                await exec(txConn, `MATCH (r:Repo {repoId: $repoId})
+           MERGE (s:Symbol {symbolId: $symbolId})
            MERGE (s)-[:SYMBOL_IN_REPO]->(r)`, { repoId, symbolId });
             }
             for (const edge of repoEdges) {
-                await exec(txConn, `MERGE (a:Symbol {symbolId: $fromSymbolId})
-           MERGE (b:Symbol {symbolId: $toSymbolId})
-           MERGE (a)-[d:DEPENDS_ON {edgeType: $edgeType}]->(b)
-           SET d.weight = $weight,
-               d.confidence = $confidence,
-               d.resolution = $resolution,
-               d.resolverId = $resolverId,
-               d.resolutionPhase = $resolutionPhase,
-               d.provenance = $provenance,
+                await exec(txConn, `MERGE (a:Symbol {symbolId: $fromSymbolId})
+           MERGE (b:Symbol {symbolId: $toSymbolId})
+           MERGE (a)-[d:DEPENDS_ON {edgeType: $edgeType}]->(b)
+           SET d.weight = $weight,
+               d.confidence = $confidence,
+               d.resolution = $resolution,
+               d.resolverId = $resolverId,
+               d.resolutionPhase = $resolutionPhase,
+               d.provenance = $provenance,
                d.createdAt = $createdAt`, {
                     fromSymbolId: edge.fromSymbolId,
                     toSymbolId: edge.toSymbolId,
@@ -112,8 +112,8 @@ export async function insertEdges(conn, edges) {
     });
 }
 export async function deleteEdge(conn, edge) {
-    await exec(conn, `MATCH (a:Symbol {symbolId: $fromSymbolId})-[d:DEPENDS_ON]->(b:Symbol {symbolId: $toSymbolId})
-     WHERE d.edgeType = $edgeType
+    await exec(conn, `MATCH (a:Symbol {symbolId: $fromSymbolId})-[d:DEPENDS_ON]->(b:Symbol {symbolId: $toSymbolId})
+     WHERE d.edgeType = $edgeType
      DELETE d`, {
         fromSymbolId: edge.fromSymbolId,
         toSymbolId: edge.toSymbolId,
@@ -122,19 +122,19 @@ export async function deleteEdge(conn, edge) {
 }
 export async function getEdgesFrom(conn, symbolId, options) {
     const minCallConfidenceClause = buildMinCallConfidenceClause("d", options?.minCallConfidence);
-    const rows = await queryAll(conn, `MATCH (a:Symbol {symbolId: $symbolId})-[d:DEPENDS_ON]->(b:Symbol)
-     WHERE 1 = 1${minCallConfidenceClause}
-     MATCH (a)-[:SYMBOL_IN_REPO]->(r:Repo)
-     RETURN r.repoId AS repoId,
-            a.symbolId AS fromSymbolId,
-            b.symbolId AS toSymbolId,
-            d.edgeType AS edgeType,
-            d.weight AS weight,
-            d.confidence AS confidence,
-            d.resolution AS resolution,
-            d.resolverId AS resolverId,
-            d.resolutionPhase AS resolutionPhase,
-            d.provenance AS provenance,
+    const rows = await queryAll(conn, `MATCH (a:Symbol {symbolId: $symbolId})-[d:DEPENDS_ON]->(b:Symbol)
+     WHERE 1 = 1${minCallConfidenceClause}
+     MATCH (a)-[:SYMBOL_IN_REPO]->(r:Repo)
+     RETURN r.repoId AS repoId,
+            a.symbolId AS fromSymbolId,
+            b.symbolId AS toSymbolId,
+            d.edgeType AS edgeType,
+            d.weight AS weight,
+            d.confidence AS confidence,
+            d.resolution AS resolution,
+            d.resolverId AS resolverId,
+            d.resolutionPhase AS resolutionPhase,
+            d.provenance AS provenance,
             d.createdAt AS createdAt`, {
         symbolId,
         ...(options?.minCallConfidence !== undefined
@@ -162,19 +162,19 @@ export async function getEdgesFromSymbols(conn, symbolIds, options) {
     for (const id of symbolIds)
         result.set(id, []);
     const minCallConfidenceClause = buildMinCallConfidenceClause("d", options?.minCallConfidence);
-    const rows = await queryAll(conn, `MATCH (a:Symbol)-[d:DEPENDS_ON]->(b:Symbol)
-     WHERE a.symbolId IN $symbolIds${minCallConfidenceClause}
-     MATCH (a)-[:SYMBOL_IN_REPO]->(r:Repo)
-     RETURN r.repoId AS repoId,
-            a.symbolId AS fromSymbolId,
-            b.symbolId AS toSymbolId,
-            d.edgeType AS edgeType,
-            d.weight AS weight,
-            d.confidence AS confidence,
-            d.resolution AS resolution,
-            d.resolverId AS resolverId,
-            d.resolutionPhase AS resolutionPhase,
-            d.provenance AS provenance,
+    const rows = await queryAll(conn, `MATCH (a:Symbol)-[d:DEPENDS_ON]->(b:Symbol)
+     WHERE a.symbolId IN $symbolIds${minCallConfidenceClause}
+     MATCH (a)-[:SYMBOL_IN_REPO]->(r:Repo)
+     RETURN r.repoId AS repoId,
+            a.symbolId AS fromSymbolId,
+            b.symbolId AS toSymbolId,
+            d.edgeType AS edgeType,
+            d.weight AS weight,
+            d.confidence AS confidence,
+            d.resolution AS resolution,
+            d.resolverId AS resolverId,
+            d.resolutionPhase AS resolutionPhase,
+            d.provenance AS provenance,
             d.createdAt AS createdAt`, {
         symbolIds,
         ...(options?.minCallConfidence !== undefined
@@ -208,15 +208,15 @@ export async function getEdgesFromSymbolsForSlice(conn, symbolIds, options) {
     for (const id of symbolIds)
         result.set(id, []);
     const minCallConfidenceClause = buildMinCallConfidenceClause("d", options?.minCallConfidence);
-    const rows = await queryAll(conn, `MATCH (a:Symbol)-[d:DEPENDS_ON]->(b:Symbol)
-     WHERE a.symbolId IN $symbolIds${minCallConfidenceClause}
-     RETURN a.symbolId AS fromSymbolId,
-            b.symbolId AS toSymbolId,
-            d.edgeType AS edgeType,
-            d.weight AS weight,
-            d.confidence AS confidence,
-            d.resolution AS resolution,
-            d.resolverId AS resolverId,
+    const rows = await queryAll(conn, `MATCH (a:Symbol)-[d:DEPENDS_ON]->(b:Symbol)
+     WHERE a.symbolId IN $symbolIds${minCallConfidenceClause}
+     RETURN a.symbolId AS fromSymbolId,
+            b.symbolId AS toSymbolId,
+            d.edgeType AS edgeType,
+            d.weight AS weight,
+            d.confidence AS confidence,
+            d.resolution AS resolution,
+            d.resolverId AS resolverId,
             d.resolutionPhase AS resolutionPhase`, {
         symbolIds,
         ...(options?.minCallConfidence !== undefined
@@ -246,10 +246,10 @@ export async function getEdgesFromSymbolsLite(conn, symbolIds) {
     const result = new Map();
     for (const id of symbolIds)
         result.set(id, []);
-    const rows = await queryAll(conn, `MATCH (a:Symbol)-[d:DEPENDS_ON]->(b:Symbol)
-     WHERE a.symbolId IN $symbolIds
-     RETURN a.symbolId AS fromSymbolId,
-            b.symbolId AS toSymbolId,
+    const rows = await queryAll(conn, `MATCH (a:Symbol)-[d:DEPENDS_ON]->(b:Symbol)
+     WHERE a.symbolId IN $symbolIds
+     RETURN a.symbolId AS fromSymbolId,
+            b.symbolId AS toSymbolId,
             d.edgeType AS edgeType`, { symbolIds });
     for (const row of rows) {
         const bucket = result.get(row.fromSymbolId);
@@ -270,41 +270,41 @@ export async function getEdgesToSymbols(conn, symbolIds, options) {
     for (const id of symbolIds)
         result.set(id, []);
     const minCallConfidenceClause = buildMinCallConfidenceClause("d", options?.minCallConfidence);
-    const queryWithHint = `MATCH (b:Symbol)
-     WHERE b.symbolId IN $symbolIds
-     MATCH (a:Symbol)-[d:DEPENDS_ON]->(b)
-     WHERE 1 = 1${minCallConfidenceClause}
-     MATCH (a)-[:SYMBOL_IN_REPO]->(r:Repo)
-     WITH b, d, a, r
-     HINT (b JOIN (d JOIN a))
-     RETURN r.repoId AS repoId,
-            a.symbolId AS fromSymbolId,
-            b.symbolId AS toSymbolId,
-            d.edgeType AS edgeType,
-            d.weight AS weight,
-            d.confidence AS confidence,
-            d.resolution AS resolution,
-            d.resolverId AS resolverId,
-            d.resolutionPhase AS resolutionPhase,
-            d.provenance AS provenance,
-            d.createdAt AS createdAt
+    const queryWithHint = `MATCH (b:Symbol)
+     WHERE b.symbolId IN $symbolIds
+     MATCH (a:Symbol)-[d:DEPENDS_ON]->(b)
+     WHERE 1 = 1${minCallConfidenceClause}
+     MATCH (a)-[:SYMBOL_IN_REPO]->(r:Repo)
+     WITH b, d, a, r
+     HINT (b JOIN (d JOIN a))
+     RETURN r.repoId AS repoId,
+            a.symbolId AS fromSymbolId,
+            b.symbolId AS toSymbolId,
+            d.edgeType AS edgeType,
+            d.weight AS weight,
+            d.confidence AS confidence,
+            d.resolution AS resolution,
+            d.resolverId AS resolverId,
+            d.resolutionPhase AS resolutionPhase,
+            d.provenance AS provenance,
+            d.createdAt AS createdAt
      ORDER BY a.symbolId`;
-    const queryWithoutHint = `MATCH (b:Symbol)
-     WHERE b.symbolId IN $symbolIds
-     MATCH (a:Symbol)-[d:DEPENDS_ON]->(b)
-     WHERE 1 = 1${minCallConfidenceClause}
-     MATCH (a)-[:SYMBOL_IN_REPO]->(r:Repo)
-     RETURN r.repoId AS repoId,
-            a.symbolId AS fromSymbolId,
-            b.symbolId AS toSymbolId,
-            d.edgeType AS edgeType,
-            d.weight AS weight,
-            d.confidence AS confidence,
-            d.resolution AS resolution,
-            d.resolverId AS resolverId,
-            d.resolutionPhase AS resolutionPhase,
-            d.provenance AS provenance,
-            d.createdAt AS createdAt
+    const queryWithoutHint = `MATCH (b:Symbol)
+     WHERE b.symbolId IN $symbolIds
+     MATCH (a:Symbol)-[d:DEPENDS_ON]->(b)
+     WHERE 1 = 1${minCallConfidenceClause}
+     MATCH (a)-[:SYMBOL_IN_REPO]->(r:Repo)
+     RETURN r.repoId AS repoId,
+            a.symbolId AS fromSymbolId,
+            b.symbolId AS toSymbolId,
+            d.edgeType AS edgeType,
+            d.weight AS weight,
+            d.confidence AS confidence,
+            d.resolution AS resolution,
+            d.resolverId AS resolverId,
+            d.resolutionPhase AS resolutionPhase,
+            d.provenance AS provenance,
+            d.createdAt AS createdAt
      ORDER BY a.symbolId`;
     const useJoinHint = await getJoinHintSupported(conn);
     const rows = await queryAll(conn, useJoinHint ? queryWithHint : queryWithoutHint, {
@@ -334,17 +334,17 @@ export async function getEdgesToSymbols(conn, symbolIds, options) {
     return result;
 }
 export async function getEdgesByRepo(conn, repoId) {
-    const rows = await queryAll(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(a:Symbol)-[d:DEPENDS_ON]->(b:Symbol)
-     RETURN r.repoId AS repoId,
-            a.symbolId AS fromSymbolId,
-            b.symbolId AS toSymbolId,
-            d.edgeType AS edgeType,
-            d.weight AS weight,
-            d.confidence AS confidence,
-            d.resolution AS resolution,
-            d.resolverId AS resolverId,
-            d.resolutionPhase AS resolutionPhase,
-            d.provenance AS provenance,
+    const rows = await queryAll(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(a:Symbol)-[d:DEPENDS_ON]->(b:Symbol)
+     RETURN r.repoId AS repoId,
+            a.symbolId AS fromSymbolId,
+            b.symbolId AS toSymbolId,
+            d.edgeType AS edgeType,
+            d.weight AS weight,
+            d.confidence AS confidence,
+            d.resolution AS resolution,
+            d.resolverId AS resolverId,
+            d.resolutionPhase AS resolutionPhase,
+            d.provenance AS provenance,
             d.createdAt AS createdAt`, { repoId });
     return rows.map((row) => ({
         repoId: row.repoId,
@@ -363,48 +363,48 @@ export async function getEdgesByRepo(conn, repoId) {
 export async function getCallersOfSymbols(conn, repoId, symbolIds) {
     if (symbolIds.length === 0)
         return [];
-    const queryWithHint = `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(to:Symbol)
-     WHERE to.symbolId IN $symbolIds
-     MATCH (from:Symbol)-[d:DEPENDS_ON]->(to)
-     MATCH (from)-[:SYMBOL_IN_REPO]->(r)
-     WHERE d.edgeType IN ['call', 'import']
-     WITH r, to, d, from
-     HINT (to JOIN (d JOIN from))
-     RETURN DISTINCT from.symbolId AS symbolId
+    const queryWithHint = `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(to:Symbol)
+     WHERE to.symbolId IN $symbolIds
+     MATCH (from:Symbol)-[d:DEPENDS_ON]->(to)
+     MATCH (from)-[:SYMBOL_IN_REPO]->(r)
+     WHERE d.edgeType IN ['call', 'import']
+     WITH r, to, d, from
+     HINT (to JOIN (d JOIN from))
+     RETURN DISTINCT from.symbolId AS symbolId
      ORDER BY symbolId`;
-    const queryWithoutHint = `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(to:Symbol)
-     WHERE to.symbolId IN $symbolIds
-     MATCH (from:Symbol)-[d:DEPENDS_ON]->(to)
-     MATCH (from)-[:SYMBOL_IN_REPO]->(r)
-     WHERE d.edgeType IN ['call', 'import']
-     RETURN DISTINCT from.symbolId AS symbolId
+    const queryWithoutHint = `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(to:Symbol)
+     WHERE to.symbolId IN $symbolIds
+     MATCH (from:Symbol)-[d:DEPENDS_ON]->(to)
+     MATCH (from)-[:SYMBOL_IN_REPO]->(r)
+     WHERE d.edgeType IN ['call', 'import']
+     RETURN DISTINCT from.symbolId AS symbolId
      ORDER BY symbolId`;
     const useJoinHint = await getJoinHintSupported(conn);
     const rows = await queryAll(conn, useJoinHint ? queryWithHint : queryWithoutHint, { repoId, symbolIds });
     return rows.map((row) => row.symbolId);
 }
 export async function deleteEdgesByFileId(conn, fileId) {
-    const symbolRows = await queryAll(conn, `MATCH (f:File {fileId: $fileId})<-[:SYMBOL_IN_FILE]-(s:Symbol)
+    const symbolRows = await queryAll(conn, `MATCH (f:File {fileId: $fileId})<-[:SYMBOL_IN_FILE]-(s:Symbol)
      RETURN s.symbolId AS symbolId`, { fileId });
     const symbolIds = symbolRows.map((r) => r.symbolId);
     if (symbolIds.length === 0)
         return;
-    await exec(conn, `MATCH (s:Symbol)-[d:DEPENDS_ON]->(:Symbol)
-     WHERE s.symbolId IN $symbolIds
+    await exec(conn, `MATCH (s:Symbol)-[d:DEPENDS_ON]->(:Symbol)
+     WHERE s.symbolId IN $symbolIds
      DELETE d`, { symbolIds });
-    await exec(conn, `MATCH (:Symbol)-[d:DEPENDS_ON]->(s:Symbol)
-     WHERE s.symbolId IN $symbolIds
+    await exec(conn, `MATCH (:Symbol)-[d:DEPENDS_ON]->(s:Symbol)
+     WHERE s.symbolId IN $symbolIds
      DELETE d`, { symbolIds });
 }
 export async function deleteOutgoingEdgesByTypeForSymbols(conn, symbolIds, edgeType) {
     if (symbolIds.length === 0)
         return;
-    await exec(conn, `MATCH (s:Symbol)-[d:DEPENDS_ON]->(:Symbol)
-     WHERE s.symbolId IN $symbolIds AND d.edgeType = $edgeType
+    await exec(conn, `MATCH (s:Symbol)-[d:DEPENDS_ON]->(:Symbol)
+     WHERE s.symbolId IN $symbolIds AND d.edgeType = $edgeType
      DELETE d`, { symbolIds, edgeType });
 }
 export async function getEdgeCountsByType(conn, repoId) {
-    const rows = await queryAll(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)-[d:DEPENDS_ON]->(:Symbol)
+    const rows = await queryAll(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)-[d:DEPENDS_ON]->(:Symbol)
      RETURN d.edgeType AS edgeType, count(d) AS count`, { repoId });
     const result = {};
     for (const row of rows) {
@@ -413,24 +413,24 @@ export async function getEdgeCountsByType(conn, repoId) {
     return result;
 }
 export async function getEdgeCount(conn, repoId) {
-    const row = await querySingle(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)-[d:DEPENDS_ON]->(:Symbol)
+    const row = await querySingle(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)-[d:DEPENDS_ON]->(:Symbol)
      RETURN count(d) AS count`, { repoId });
     return row ? toNumber(row.count) : 0;
 }
 export async function getCallEdgeResolutionCounts(conn, repoId) {
-    const total = await querySingle(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)-[d:DEPENDS_ON]->(:Symbol)
-     WHERE d.edgeType = 'call'
+    const total = await querySingle(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)-[d:DEPENDS_ON]->(:Symbol)
+     WHERE d.edgeType = 'call'
      RETURN count(d) AS count`, { repoId });
-    const resolved = await querySingle(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)-[d:DEPENDS_ON]->(t:Symbol)
-     WHERE d.edgeType = 'call' AND NOT (t.symbolId STARTS WITH 'unresolved:')
+    const resolved = await querySingle(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)-[d:DEPENDS_ON]->(t:Symbol)
+     WHERE d.edgeType = 'call' AND NOT (t.symbolId STARTS WITH 'unresolved:')
      RETURN count(d) AS count`, { repoId });
-    const exact = await querySingle(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)-[d:DEPENDS_ON]->(:Symbol)
-     WHERE d.edgeType = 'call' AND (d.resolution = 'exact' OR d.confidence >= 0.9)
+    const exact = await querySingle(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)-[d:DEPENDS_ON]->(:Symbol)
+     WHERE d.edgeType = 'call' AND (d.resolution = 'exact' OR d.confidence >= 0.9)
      RETURN count(d) AS count`, { repoId });
     // Count of call edges that target repo-internal symbols (resolvable)
     // Excludes edges targeting 'unresolved:call:' stubs (external/builtin calls)
-    const resolvable = await querySingle(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)-[d:DEPENDS_ON]->(t:Symbol)
-     WHERE d.edgeType = 'call' AND NOT (t.symbolId STARTS WITH 'unresolved:call:')
+    const resolvable = await querySingle(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)-[d:DEPENDS_ON]->(t:Symbol)
+     WHERE d.edgeType = 'call' AND NOT (t.symbolId STARTS WITH 'unresolved:call:')
      RETURN count(d) AS count`, { repoId });
     return {
         totalCallEdges: total ? toNumber(total.count) : 0,

package/dist/db/ladybug-feedback.js

@@ -1,12 +1,12 @@
 import { exec, queryAll, querySingle, assertSafeInt } from "./ladybug-core.js";
 import { safeJsonParse, StringArraySchema } from "../util/safeJson.js";
 export async function insertAuditEvent(conn, row) {
-    await exec(conn, `MERGE (a:Audit {eventId: $eventId})
-     SET a.timestamp = $timestamp,
-         a.tool = $tool,
-         a.decision = $decision,
-         a.repoId = $repoId,
-         a.symbolId = $symbolId,
+    await exec(conn, `MERGE (a:Audit {eventId: $eventId})
+     SET a.timestamp = $timestamp,
+         a.tool = $tool,
+         a.decision = $decision,
+         a.repoId = $repoId,
+         a.symbolId = $symbolId,
          a.detailsJson = $detailsJson`, {
         eventId: row.eventId,
         timestamp: row.timestamp,
@@ -36,29 +36,29 @@ export async function getAuditEvents(conn, options = {}) {
         params.untilTimestamp = options.untilTimestamp;
     }
     const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    const rows = await queryAll(conn, `MATCH (a:Audit)
-     ${whereClause}
-     RETURN a.eventId AS eventId,
-            a.timestamp AS timestamp,
-            a.tool AS tool,
-            a.decision AS decision,
-            a.repoId AS repoId,
-            a.symbolId AS symbolId,
-            a.detailsJson AS detailsJson
-     ORDER BY a.timestamp DESC
+    const rows = await queryAll(conn, `MATCH (a:Audit)
+     ${whereClause}
+     RETURN a.eventId AS eventId,
+            a.timestamp AS timestamp,
+            a.tool AS tool,
+            a.decision AS decision,
+            a.repoId AS repoId,
+            a.symbolId AS symbolId,
+            a.detailsJson AS detailsJson
+     ORDER BY a.timestamp DESC
      LIMIT $limit`, { ...params, limit: maxFetch });
     return rows;
 }
 export async function upsertAgentFeedback(conn, row) {
-    await exec(conn, `MERGE (f:AgentFeedback {feedbackId: $feedbackId})
-     SET f.repoId = $repoId,
-         f.versionId = $versionId,
-         f.sliceHandle = $sliceHandle,
-         f.usefulSymbolsJson = $usefulSymbolsJson,
-         f.missingSymbolsJson = $missingSymbolsJson,
-         f.taskTagsJson = $taskTagsJson,
-         f.taskType = $taskType,
-         f.taskText = $taskText,
+    await exec(conn, `MERGE (f:AgentFeedback {feedbackId: $feedbackId})
+     SET f.repoId = $repoId,
+         f.versionId = $versionId,
+         f.sliceHandle = $sliceHandle,
+         f.usefulSymbolsJson = $usefulSymbolsJson,
+         f.missingSymbolsJson = $missingSymbolsJson,
+         f.taskTagsJson = $taskTagsJson,
+         f.taskType = $taskType,
+         f.taskText = $taskText,
          f.createdAt = $createdAt`, {
         feedbackId: row.feedbackId,
         repoId: row.repoId,
@@ -73,16 +73,16 @@ export async function upsertAgentFeedback(conn, row) {
     });
 }
 export async function getAgentFeedback(conn, feedbackId) {
-    const row = await querySingle(conn, `MATCH (f:AgentFeedback {feedbackId: $feedbackId})
-     RETURN f.feedbackId AS feedbackId,
-            f.repoId AS repoId,
-            f.versionId AS versionId,
-            f.sliceHandle AS sliceHandle,
-            f.usefulSymbolsJson AS usefulSymbolsJson,
-            f.missingSymbolsJson AS missingSymbolsJson,
-            f.taskTagsJson AS taskTagsJson,
-            f.taskType AS taskType,
-            f.taskText AS taskText,
+    const row = await querySingle(conn, `MATCH (f:AgentFeedback {feedbackId: $feedbackId})
+     RETURN f.feedbackId AS feedbackId,
+            f.repoId AS repoId,
+            f.versionId AS versionId,
+            f.sliceHandle AS sliceHandle,
+            f.usefulSymbolsJson AS usefulSymbolsJson,
+            f.missingSymbolsJson AS missingSymbolsJson,
+            f.taskTagsJson AS taskTagsJson,
+            f.taskType AS taskType,
+            f.taskText AS taskText,
             f.createdAt AS createdAt`, { feedbackId });
     return row ?? null;
 }
@@ -90,32 +90,32 @@ export async function getAgentFeedbackByRepo(conn, repoId, limit, since) {
     assertSafeInt(limit, "limit");
     const maxFetch = Math.min(Math.max(0, limit), 10000);
     const query = since
-        ? `MATCH (f:AgentFeedback {repoId: $repoId})
-       WHERE f.createdAt >= $since
-       RETURN f.feedbackId AS feedbackId,
-              f.repoId AS repoId,
-              f.versionId AS versionId,
-              f.sliceHandle AS sliceHandle,
-              f.usefulSymbolsJson AS usefulSymbolsJson,
-              f.missingSymbolsJson AS missingSymbolsJson,
-              f.taskTagsJson AS taskTagsJson,
-              f.taskType AS taskType,
-              f.taskText AS taskText,
-              f.createdAt AS createdAt
-       ORDER BY f.createdAt DESC
+        ? `MATCH (f:AgentFeedback {repoId: $repoId})
+       WHERE f.createdAt >= $since
+       RETURN f.feedbackId AS feedbackId,
+              f.repoId AS repoId,
+              f.versionId AS versionId,
+              f.sliceHandle AS sliceHandle,
+              f.usefulSymbolsJson AS usefulSymbolsJson,
+              f.missingSymbolsJson AS missingSymbolsJson,
+              f.taskTagsJson AS taskTagsJson,
+              f.taskType AS taskType,
+              f.taskText AS taskText,
+              f.createdAt AS createdAt
+       ORDER BY f.createdAt DESC
        LIMIT $limit`
-        : `MATCH (f:AgentFeedback {repoId: $repoId})
-       RETURN f.feedbackId AS feedbackId,
-              f.repoId AS repoId,
-              f.versionId AS versionId,
-              f.sliceHandle AS sliceHandle,
-              f.usefulSymbolsJson AS usefulSymbolsJson,
-              f.missingSymbolsJson AS missingSymbolsJson,
-              f.taskTagsJson AS taskTagsJson,
-              f.taskType AS taskType,
-              f.taskText AS taskText,
-              f.createdAt AS createdAt
-       ORDER BY f.createdAt DESC
+        : `MATCH (f:AgentFeedback {repoId: $repoId})
+       RETURN f.feedbackId AS feedbackId,
+              f.repoId AS repoId,
+              f.versionId AS versionId,
+              f.sliceHandle AS sliceHandle,
+              f.usefulSymbolsJson AS usefulSymbolsJson,
+              f.missingSymbolsJson AS missingSymbolsJson,
+              f.taskTagsJson AS taskTagsJson,
+              f.taskType AS taskType,
+              f.taskText AS taskText,
+              f.createdAt AS createdAt
+       ORDER BY f.createdAt DESC
        LIMIT $limit`;
     const rows = await queryAll(conn, query, since ? { repoId, since, limit: maxFetch } : { repoId, limit: maxFetch });
     return rows;
@@ -161,12 +161,12 @@ export async function getAggregatedFeedback(conn, repoId, sinceTimestamp) {
         conditions.push("f.createdAt >= $sinceTimestamp");
         params.sinceTimestamp = sinceTimestamp;
     }
-    const rows = await queryAll(conn, `MATCH (f:AgentFeedback)
-     WHERE ${conditions.join(" AND ")}
-     RETURN f.usefulSymbolsJson AS usefulSymbolsJson,
-            f.missingSymbolsJson AS missingSymbolsJson,
-            f.taskTagsJson AS taskTagsJson,
-            f.taskType AS taskType
+    const rows = await queryAll(conn, `MATCH (f:AgentFeedback)
+     WHERE ${conditions.join(" AND ")}
+     RETURN f.usefulSymbolsJson AS usefulSymbolsJson,
+            f.missingSymbolsJson AS missingSymbolsJson,
+            f.taskTagsJson AS taskTagsJson,
+            f.taskType AS taskType
      ORDER BY f.createdAt DESC`, params);
     const symbolPositiveCounts = new Map();
     const symbolNegativeCounts = new Map();