recallx 1.1.0 → 1.2.0

package/app/server/app.js

@@ -4,13 +4,14 @@ import { fileURLToPath } from "node:url";
 import cors from "cors";
 import express from "express";
 import mime from "mime-types";
-import { activitySearchSchema, appendActivitySchema, appendRelationUsageEventSchema, appendSearchFeedbackSchema, attachArtifactSchema, buildContextBundleSchema, captureMemorySchema, createWorkspaceSchema, createNodeSchema, createNodesSchema, createRelationSchema, governanceIssuesQuerySchema, nodeSearchSchema, openWorkspaceSchema, reindexInferredRelationsSchema, recomputeGovernanceSchema, recomputeInferredRelationsSchema, relationTypes, registerIntegrationSchema, sourceSchema, upsertInferredRelationSchema, updateIntegrationSchema, updateNodeSchema, updateRelationSchema, updateSettingsSchema, workspaceSearchSchema } from "../shared/contracts.js";
+import { activitySearchSchema, appendActivitySchema, appendRelationUsageEventSchema, appendSearchFeedbackSchema, attachArtifactSchema, buildContextBundleSchema, captureMemorySchema, createWorkspaceBackupSchema, createWorkspaceSchema, createNodeSchema, createNodesSchema, createRelationSchema, exportWorkspaceSchema, governanceEventsQuerySchema, governanceNodeActionSchema, governanceRelationActionSchema, governanceIssuesQuerySchema, importWorkspacePreviewSchema, importWorkspaceSchema, nodeSearchSchema, openWorkspaceSchema, reindexInferredRelationsSchema, recomputeGovernanceSchema, recomputeInferredRelationsSchema, relationTypes, registerIntegrationSchema, restoreWorkspaceBackupSchema, sourceSchema, upsertInferredRelationSchema, updateIntegrationSchema, updateNodeSchema, updateRelationSchema, updateSettingsSchema, workspaceSearchSchema } from "../shared/contracts.js";
 import { AppError } from "./errors.js";
 import { isShortLogLikeAgentNodeInput, maybeCreatePromotionCandidate, recomputeAutomaticGovernance, resolveGovernancePolicy, resolveNodeGovernance, resolveRelationStatus, shouldPromoteActivitySummary } from "./governance.js";
 import { refreshAutomaticInferredRelationsForNode, reindexAutomaticInferredRelations } from "./inferred-relations.js";
 import { appendCurrentTelemetryDetails, createObservabilityWriter, summarizePayloadShape } from "./observability.js";
 import { buildSemanticCandidateBonusMap, buildCandidateRelationBonusMap, buildContextBundle, buildNeighborhoodItems, buildNeighborhoodItemsBatch, buildTargetRelatedRetrievalItems, bundleAsMarkdown, computeRankCandidateScore, selectSemanticCandidateIds, shouldUseSemanticCandidateAugmentation } from "./retrieval.js";
 import { buildProjectGraph } from "./project-graph.js";
+import { isReadonlySqliteWriteError } from "./sqlite-errors.js";
 import { createId, isPathWithinRoot } from "./utils.js";
 const relationTypeSet = new Set(relationTypes);
 const allowedLoopbackHostnames = new Set(["127.0.0.1", "localhost", "::1", "[::1]"]);
@@ -494,6 +495,31 @@ function buildServiceIndex(workspaceInfo) {
                 requestExample: {
                     rootPath: "/Users/name/Documents/RecallX-Personal"
                 }
+            },
+            {
+                method: "POST",
+                path: "/api/v1/workspaces/backups",
+                purpose: "Create a manual workspace snapshot before risky changes.",
+                requestExample: {
+                    label: "before-upgrade"
+                }
+            },
+            {
+                method: "POST",
+                path: "/api/v1/workspaces/restore",
+                purpose: "Restore a snapshot into a new workspace root and switch to it.",
+                requestExample: {
+                    backupId: "20260330123000-before-upgrade",
+                    targetRootPath: "/Users/name/Documents/RecallX-Restore"
+                }
+            },
+            {
+                method: "POST",
+                path: "/api/v1/workspaces/export",
+                purpose: "Export the active workspace to a portable file under exports/.",
+                requestExample: {
+                    format: "json"
+                }
             }
         ],
         references: {
@@ -1008,7 +1034,9 @@ export function createRecallXApp(params) {
                         }
                     }
                     catch (error) {
-                        console.error(`Failed to refresh inferred relations for node ${nodeId}`, error);
+                        if (!isReadonlySqliteWriteError(error)) {
+                            console.error(`Failed to refresh inferred relations for node ${nodeId}`, error);
+                        }
                     }
                 }
                 if (processedNodes > 0) {
@@ -1180,7 +1208,13 @@ export function createRecallXApp(params) {
         };
     }
     function createDurableNodeResponse(repository, input) {
-        const governance = resolveNodeGovernance(input, resolveGovernancePolicy(repository.getSettings(["review.autoApproveLowRisk", "review.trustedSourceToolNames"])));
+        const governancePolicy = resolveGovernancePolicy(repository.getSettings(["review.autoApproveLowRisk", "review.trustedSourceToolNames"]));
+        const rawProjectId = typeof input.metadata.projectId === "string" ? input.metadata.projectId.trim() : "";
+        const linkedProject = rawProjectId ? repository.getNode(rawProjectId) : null;
+        if (linkedProject && (linkedProject.type !== "project" || linkedProject.status === "archived")) {
+            throw new AppError(400, "INVALID_INPUT", "metadata.projectId must reference an active project node.");
+        }
+        const governance = resolveNodeGovernance(input, governancePolicy);
         const node = repository.createNode({
             ...input,
             resolvedCanonicality: governance.canonicality,
@@ -1196,7 +1230,48 @@ export function createRecallXApp(params) {
             }
         });
         const governanceResult = recomputeGovernanceForEntities("node", [node.id]);
-        queueInferredRefresh(node.id, "node-write");
+        if (linkedProject) {
+            if (linkedProject.id !== node.id) {
+                const relationInput = {
+                    fromNodeId: node.id,
+                    toNodeId: linkedProject.id,
+                    relationType: "relevant_to",
+                    source: input.source,
+                    metadata: {
+                        createdFrom: "project-aware-capture",
+                        projectId: linkedProject.id,
+                    },
+                };
+                const relationGovernance = resolveRelationStatus(relationInput, governancePolicy);
+                const relation = repository.createRelation({
+                    ...relationInput,
+                    resolvedStatus: relationGovernance.status,
+                });
+                repository.recordProvenance({
+                    entityType: "relation",
+                    entityId: relation.id,
+                    operationType: "create",
+                    source: input.source,
+                    metadata: {
+                        reason: relationGovernance.reason,
+                        createdFrom: "project-aware-capture",
+                    },
+                });
+                recomputeGovernanceForEntities("relation", [relation.id]);
+                queueInferredRefreshForNodes([node.id, linkedProject.id], "node-write");
+                broadcastWorkspaceEvent({
+                    reason: "relation.created",
+                    entityType: "relation",
+                    entityId: relation.id,
+                });
+            }
+            else {
+                queueInferredRefresh(node.id, "node-write");
+            }
+        }
+        else {
+            queueInferredRefresh(node.id, "node-write");
+        }
         scheduleAutoSemanticIndex();
         broadcastWorkspaceEvent({
             reason: "node.created",
@@ -1403,6 +1478,50 @@ export function createRecallXApp(params) {
         const workspace = params.workspaceSessionManager.openWorkspace(input.rootPath);
         commitWorkspaceMutation(response, workspace, "workspace.opened");
     });
+    app.get("/api/v1/workspaces/backups", (_request, response) => {
+        response.json(envelope(response.locals.requestId, {
+            items: params.workspaceSessionManager.listBackups()
+        }));
+    });
+    app.post("/api/v1/workspaces/backups", (request, response) => {
+        const input = createWorkspaceBackupSchema.parse(request.body ?? {});
+        const backup = params.workspaceSessionManager.createBackup(input.label);
+        response.status(201).json(envelope(response.locals.requestId, { backup }));
+    });
+    app.post("/api/v1/workspaces/export", (request, response) => {
+        const input = exportWorkspaceSchema.parse(request.body ?? {});
+        const exportRecord = params.workspaceSessionManager.exportWorkspace(input.format);
+        response.status(201).json(envelope(response.locals.requestId, { export: exportRecord }));
+    });
+    app.post("/api/v1/workspaces/import/preview", (request, response) => {
+        const input = importWorkspacePreviewSchema.parse(request.body ?? {});
+        const preview = params.workspaceSessionManager.previewImportWorkspace(input.format, input.sourcePath, input.label, input.options);
+        response.json(envelope(response.locals.requestId, { preview }));
+    });
+    app.post("/api/v1/workspaces/import", (request, response) => {
+        const input = importWorkspaceSchema.parse(request.body ?? {});
+        const importRecord = params.workspaceSessionManager.importWorkspace(input.format, input.sourcePath, input.label, input.options);
+        refreshWorkspaceState();
+        broadcastWorkspaceEvent({
+            reason: "workspace.imported",
+            entityType: "workspace"
+        });
+        response.status(201).json(envelope(response.locals.requestId, { import: importRecord }));
+    });
+    app.post("/api/v1/workspaces/restore", (request, response) => {
+        const input = restoreWorkspaceBackupSchema.parse(request.body ?? {});
+        const result = params.workspaceSessionManager.restoreBackup(input.backupId, input.targetRootPath, input.workspaceName);
+        refreshWorkspaceState();
+        broadcastWorkspaceEvent({
+            reason: "workspace.restored",
+            entityType: "workspace"
+        });
+        response.status(201).json(envelope(response.locals.requestId, {
+            restoredBackupId: input.backupId,
+            autoBackup: result.autoBackup,
+            ...buildWorkspaceMutationPayload(result.workspace)
+        }));
+    });
     app.get("/api/v1/observability/summary", handleAsyncRoute(async (request, response) => {
         const summary = await observability.summarize({
             since: readRequestParam(request.query.since),
@@ -1476,6 +1595,21 @@ export function createRecallXApp(params) {
             scopes: input.scopes
         }, async (span) => {
             const searchResult = await currentRepository().searchWorkspace(input, {
+                runSearchStageSpan: async (operation, details, callback) => runObservedSpan(operation, details, async (stageSpan) => {
+                    const stageResult = await callback();
+                    if (stageResult &&
+                        typeof stageResult === "object" &&
+                        "items" in stageResult &&
+                        Array.isArray(stageResult.items) &&
+                        "total" in stageResult &&
+                        typeof stageResult.total === "number") {
+                        stageSpan.addDetails({
+                            resultCount: stageResult.items.length,
+                            totalCount: stageResult.total
+                        });
+                    }
+                    return stageResult;
+                }),
                 runSemanticFallbackSpan: async (details, callback) => runObservedSpan("workspace.search.semantic_fallback", {
                     ...details,
                     mcpTool: request.header("x-recallx-mcp-tool") ?? null
@@ -1723,6 +1857,157 @@ export function createRecallXApp(params) {
             governance: buildGovernancePayload(repository, "node", node.id, governanceResult.items[0] ?? repository.getGovernanceStateNullable("node", node.id))
         }));
     });
+    app.post("/api/v1/nodes/:id/governance-action", (request, response) => {
+        const repository = currentRepository();
+        const input = governanceNodeActionSchema.parse(request.body ?? {});
+        const note = input.note?.trim() ? input.note.trim() : null;
+        const nodeId = request.params.id;
+        const beforeNode = repository.getNode(nodeId);
+        const previousState = repository.getGovernanceStateNullable("node", nodeId);
+        const now = new Date().toISOString();
+        let node = beforeNode;
+        let nextState = previousState?.state ?? "low_confidence";
+        let confidence = previousState?.confidence ?? 0.5;
+        let eventType;
+        let operationType;
+        let reason;
+        switch (input.action) {
+            case "promote": {
+                if (beforeNode.status === "archived") {
+                    throw new AppError(409, "INVALID_STATE", "Archived nodes cannot be promoted.");
+                }
+                node = repository.updateNode(nodeId, {
+                    status: "active",
+                    metadata: {
+                        manualGovernanceAction: "promote",
+                        manualGovernanceAt: now
+                    }
+                });
+                node = repository.setNodeCanonicality(nodeId, "canonical");
+                nextState = "healthy";
+                confidence = Math.max(previousState?.confidence ?? 0, 0.96);
+                eventType = "promoted";
+                operationType = "promote";
+                reason = note
+                    ? `Human promoted this node to canonical. ${note}`
+                    : "Human promoted this node to canonical from the governance surface.";
+                break;
+            }
+            case "contest": {
+                if (beforeNode.status === "archived") {
+                    throw new AppError(409, "INVALID_STATE", "Archived nodes cannot be contested.");
+                }
+                node = repository.updateNode(nodeId, {
+                    status: "contested",
+                    metadata: {
+                        manualGovernanceAction: "contest",
+                        manualGovernanceAt: now
+                    }
+                });
+                nextState = "contested";
+                confidence = Math.min(previousState?.confidence ?? 0.4, 0.32);
+                eventType = "contested";
+                operationType = "contest";
+                reason = note
+                    ? `Human marked this node contested. ${note}`
+                    : "Human marked this node contested from the governance surface.";
+                break;
+            }
+            case "archive": {
+                if (beforeNode.status === "archived") {
+                    throw new AppError(409, "INVALID_STATE", "Node is already archived.");
+                }
+                node = repository.archiveNode(nodeId);
+                nextState = previousState?.state === "contested" ? "contested" : "low_confidence";
+                confidence = Math.min(previousState?.confidence ?? 0.4, 0.2);
+                eventType = "demoted";
+                operationType = "archive";
+                reason = note
+                    ? `Human archived this node from governance. ${note}`
+                    : "Human archived this node from the governance surface.";
+                break;
+            }
+        }
+        repository.recordProvenance({
+            entityType: "node",
+            entityId: node.id,
+            operationType,
+            source: input.source,
+            metadata: {
+                action: input.action,
+                note,
+                previousStatus: beforeNode.status,
+                nextStatus: node.status,
+                previousCanonicality: beforeNode.canonicality,
+                nextCanonicality: node.canonicality,
+                ...input.metadata
+            }
+        });
+        const activity = repository.appendActivity({
+            targetNodeId: node.id,
+            activityType: "review_action",
+            body: reason,
+            source: input.source,
+            metadata: {
+                action: input.action,
+                previousState: previousState?.state ?? "none",
+                nextState,
+                previousStatus: beforeNode.status,
+                nextStatus: node.status,
+                previousCanonicality: beforeNode.canonicality,
+                nextCanonicality: node.canonicality,
+                note: note ?? "",
+                ...input.metadata
+            }
+        });
+        const governanceState = repository.upsertGovernanceState({
+            entityType: "node",
+            entityId: node.id,
+            state: nextState,
+            confidence,
+            reasons: [reason],
+            lastEvaluatedAt: now,
+            metadata: {
+                manualAction: input.action,
+                note: note ?? "",
+                source: input.source.actorLabel
+            },
+            previousState
+        });
+        repository.appendGovernanceEvent({
+            entityType: "node",
+            entityId: node.id,
+            eventType,
+            previousState: previousState?.state ?? null,
+            nextState,
+            confidence,
+            reason,
+            metadata: {
+                manualAction: input.action,
+                note: note ?? "",
+                previousStatus: beforeNode.status,
+                nextStatus: node.status,
+                previousCanonicality: beforeNode.canonicality,
+                nextCanonicality: node.canonicality
+            }
+        });
+        queueInferredRefresh(node.id, "node-write");
+        scheduleAutoSemanticIndex();
+        broadcastWorkspaceEvent({
+            reason: input.action === "promote"
+                ? "node.promoted"
+                : input.action === "contest"
+                    ? "node.contested"
+                    : "node.archived",
+            entityType: "node",
+            entityId: node.id
+        });
+        response.json(envelope(response.locals.requestId, {
+            node,
+            activity,
+            governance: buildGovernancePayload(repository, "node", node.id, governanceState)
+        }));
+    });
     app.post("/api/v1/nodes/:id/archive", (request, response) => {
         const repository = currentRepository();
         const source = sourceSchema.parse(request.body?.source ?? request.body ?? {});
@@ -2014,6 +2299,117 @@ export function createRecallXApp(params) {
             governance: buildGovernancePayload(repository, "relation", relation.id, governanceResult.items[0] ?? repository.getGovernanceStateNullable("relation", relation.id))
         }));
     });
+    app.get("/api/v1/relations/:id", (request, response) => {
+        const repository = currentRepository();
+        const relation = repository.getRelation(request.params.id);
+        response.json(envelope(response.locals.requestId, {
+            relation,
+            fromNode: repository.getNode(relation.fromNodeId),
+            toNode: repository.getNode(relation.toNodeId),
+            governance: buildGovernancePayload(repository, "relation", relation.id)
+        }));
+    });
+    app.post("/api/v1/relations/:id/governance-action", (request, response) => {
+        const repository = currentRepository();
+        const input = governanceRelationActionSchema.parse(request.body ?? {});
+        const note = input.note?.trim() ? input.note.trim() : null;
+        const relationId = request.params.id;
+        const beforeRelation = repository.getRelation(relationId);
+        const previousState = repository.getGovernanceStateNullable("relation", relationId);
+        if (beforeRelation.status === "archived") {
+            throw new AppError(409, "INVALID_STATE", "Archived relations cannot be changed with governance actions.");
+        }
+        let nextStatus;
+        let confidence = 0.92;
+        let eventType;
+        let operationType;
+        let reason;
+        switch (input.action) {
+            case "accept":
+                nextStatus = "active";
+                confidence = Math.max(previousState?.confidence ?? 0, 0.94);
+                eventType = "promoted";
+                operationType = "approve";
+                reason = note
+                    ? `Human accepted this relation. ${note}`
+                    : "Human accepted this relation from the governance surface.";
+                break;
+            case "reject":
+                nextStatus = "rejected";
+                confidence = Math.max(previousState?.confidence ?? 0, 0.9);
+                eventType = "demoted";
+                operationType = "reject";
+                reason = note
+                    ? `Human rejected this relation. ${note}`
+                    : "Human rejected this relation from the governance surface.";
+                break;
+            case "archive":
+                nextStatus = "archived";
+                confidence = Math.max(previousState?.confidence ?? 0, 0.88);
+                eventType = "demoted";
+                operationType = "archive";
+                reason = note
+                    ? `Human archived this relation from governance. ${note}`
+                    : "Human archived this relation from the governance surface.";
+                break;
+        }
+        const relation = repository.updateRelationStatus(relationId, nextStatus);
+        repository.recordProvenance({
+            entityType: "relation",
+            entityId: relation.id,
+            operationType,
+            source: input.source,
+            metadata: {
+                action: input.action,
+                note,
+                previousStatus: beforeRelation.status,
+                nextStatus: relation.status,
+                ...input.metadata
+            }
+        });
+        const governanceState = repository.upsertGovernanceState({
+            entityType: "relation",
+            entityId: relation.id,
+            state: "healthy",
+            confidence,
+            reasons: [reason],
+            metadata: {
+                manualAction: input.action,
+                note: note ?? "",
+                source: input.source.actorLabel
+            },
+            previousState
+        });
+        repository.appendGovernanceEvent({
+            entityType: "relation",
+            entityId: relation.id,
+            eventType,
+            previousState: previousState?.state ?? null,
+            nextState: "healthy",
+            confidence,
+            reason,
+            metadata: {
+                manualAction: input.action,
+                note: note ?? "",
+                previousStatus: beforeRelation.status,
+                nextStatus: relation.status
+            }
+        });
+        queueInferredRefreshForNodes([relation.fromNodeId, relation.toNodeId], "node-write");
+        broadcastWorkspaceEvent({
+            reason: input.action === "accept"
+                ? "relation.accepted"
+                : input.action === "reject"
+                    ? "relation.rejected"
+                    : "relation.archived",
+            entityType: "relation",
+            entityId: relation.id
+        });
+        response.json(envelope(response.locals.requestId, {
+            relation,
+            governance: buildGovernancePayload(repository, "relation", relation.id, governanceState)
+        }));
+    });
     app.get("/api/v1/nodes/:id/activities", (request, response) => {
         const limit = Number(request.query.limit ?? 20);
         response.json(envelope(response.locals.requestId, {
@@ -2233,6 +2629,18 @@ export function createRecallXApp(params) {
             items: currentRepository().listGovernanceIssues(input.limit, input.states)
         }));
     });
+    app.get("/api/v1/governance/events", (request, response) => {
+        const entityTypes = parseCommaSeparatedValues(request.query.entity_types)?.filter((entityType) => entityType === "node" || entityType === "relation");
+        const actions = parseCommaSeparatedValues(request.query.actions)?.filter((action) => action === "promote" || action === "contest" || action === "archive" || action === "accept" || action === "reject");
+        const input = governanceEventsQuerySchema.parse({
+            entityTypes,
+            actions,
+            limit: Number(request.query.limit ?? 12)
+        });
+        response.json(envelope(response.locals.requestId, {
+            items: currentRepository().listRecentGovernanceEvents(input)
+        }));
+    });
     app.get("/api/v1/governance/state/:entityType/:id", (request, response) => {
         const entityType = readRequestParam(request.params.entityType);
         if (entityType !== "node" && entityType !== "relation") {

package/app/server/config.js

@@ -15,13 +15,15 @@ export function ensureApiToken(config) {
     }
     return randomBytes(24).toString("hex");
 }
-export function workspaceInfo(rootPath, config, authMode) {
+export function workspaceInfo(rootPath, config, authMode, paths, safety) {
     return {
         rootPath,
         workspaceName: config.workspaceName,
         schemaVersion: getSchemaVersion(),
         bindAddress: `${config.bindAddress}:${config.port}`,
         enabledIntegrationModes: ["read-only", "append-only"],
-        authMode
+        authMode,
+        paths,
+        safety,
     };
 }

package/app/server/index.js

@@ -11,7 +11,18 @@ const app = createRecallXApp({
     workspaceSessionManager,
     apiToken: config.apiToken ? apiToken : null
 });
-createServer(app).listen(config.port, config.bindAddress, () => {
+const server = createServer(app);
+function shutdown() {
+    try {
+        workspaceSessionManager.shutdown();
+    }
+    finally {
+        process.exit(0);
+    }
+}
+process.once("SIGINT", shutdown);
+process.once("SIGTERM", shutdown);
+server.listen(config.port, config.bindAddress, () => {
     console.log(`RecallX API listening on http://${config.bindAddress}:${config.port}`);
     if (resolveRendererDistDir()) {
         console.log(`RecallX UI available at http://${config.bindAddress}:${config.port}/`);

package/app/server/project-graph.js

@@ -6,6 +6,9 @@ const DEFAULT_PROJECT_INFERRED_LIMIT = 60;
 function relationLabel(value) {
     return value.replaceAll("_", " ");
 }
+function relationEdgeKey(sourceNodeId, targetNodeId) {
+    return `${sourceNodeId}:${targetNodeId}`;
+}
 export function buildProjectGraph(repository, projectId, options) {
     const project = repository.getNode(projectId);
     if (project.type !== "project") {
@@ -37,11 +40,11 @@ export function buildProjectGraph(repository, projectId, options) {
             .items
             .filter((item) => item.id !== projectId)
             .map((item) => item.id)
-            .filter((nodeId, index, items) => items.indexOf(nodeId) === index)
         : [];
-    const fallbackNodeMap = fallbackNodeIds.length > 0 ? repository.getNodesByIds(fallbackNodeIds) : new Map();
-    const fallbackNodes = fallbackNodeIds.length > 0
-        ? fallbackNodeIds
+    const uniqueFallbackNodeIds = Array.from(new Set(fallbackNodeIds));
+    const fallbackNodeMap = uniqueFallbackNodeIds.length > 0 ? repository.getNodesByIds(uniqueFallbackNodeIds) : new Map();
+    const fallbackNodes = uniqueFallbackNodeIds.length > 0
+        ? uniqueFallbackNodeIds
             .map((nodeId) => fallbackNodeMap.get(nodeId))
             .filter((node) => Boolean(node))
         : [];
@@ -54,9 +57,13 @@ export function buildProjectGraph(repository, projectId, options) {
         canonicalEdges = repository.listRelationsBetweenNodeIds(expandedScopedNodeIds);
         inferredEdges = includeInferred ? repository.listInferredRelationsBetweenNodeIds(expandedScopedNodeIds, inferredLimit) : [];
     }
-    const directEdgeKeys = new Set(canonicalEdges.map((edge) => `${edge.fromNodeId}:${edge.toNodeId}`));
+    const connectedEdgeKeys = new Set([
+        ...canonicalEdges.map((edge) => relationEdgeKey(edge.fromNodeId, edge.toNodeId)),
+        ...inferredEdges.map((edge) => relationEdgeKey(edge.fromNodeId, edge.toNodeId)),
+    ]);
     const syntheticFallbackEdges = fallbackNodes
-        .filter((node) => !directEdgeKeys.has(`${node.id}:${projectId}`) && !directEdgeKeys.has(`${projectId}:${node.id}`))
+        .filter((node) => !connectedEdgeKeys.has(relationEdgeKey(node.id, projectId)) &&
+        !connectedEdgeKeys.has(relationEdgeKey(projectId, node.id)))
         .map((node) => ({
         id: `project-map-fallback:${projectId}:${node.id}`,
         source: projectId,