recallx 1.0.0

package/app/server/observability.js

@@ -0,0 +1,495 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { appendFile, mkdir, readFile, readdir, unlink } from "node:fs/promises";
+import path from "node:path";
+const telemetryStorage = new AsyncLocalStorage();
+function nowIso() {
+    return new Date().toISOString();
+}
+function parseJsonLine(line) {
+    if (!line.trim()) {
+        return null;
+    }
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+}
+function roundDuration(value) {
+    return Number(value.toFixed(2));
+}
+function dateStamp(value) {
+    return value.slice(0, 10);
+}
+function normalizeRetentionDays(value) {
+    return Math.max(1, Math.trunc(value || 14));
+}
+function normalizeLimit(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return 50;
+    }
+    return Math.min(Math.max(Math.trunc(value), 1), 200);
+}
+function percentiles(durations) {
+    if (!durations.length) {
+        return {
+            avg: null,
+            p50: null,
+            p95: null,
+            p99: null
+        };
+    }
+    const sorted = [...durations].sort((left, right) => left - right);
+    const read = (percentile) => sorted[Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * percentile) - 1))];
+    const avg = sorted.reduce((sum, value) => sum + value, 0) / sorted.length;
+    return {
+        avg: roundDuration(avg),
+        p50: roundDuration(read(0.5)),
+        p95: roundDuration(read(0.95)),
+        p99: roundDuration(read(0.99))
+    };
+}
+function parseSince(since) {
+    const normalized = since?.trim();
+    if (!normalized) {
+        return Date.now() - 24 * 60 * 60 * 1000;
+    }
+    const absolute = Date.parse(normalized);
+    if (Number.isFinite(absolute)) {
+        return absolute;
+    }
+    const relativeMatch = normalized.match(/^(\d+)([smhd])$/i);
+    if (!relativeMatch) {
+        return Date.now() - 24 * 60 * 60 * 1000;
+    }
+    const amount = Number(relativeMatch[1]);
+    const unit = relativeMatch[2].toLowerCase();
+    const multiplier = unit === "s"
+        ? 1000
+        : unit === "m"
+            ? 60 * 1000
+            : unit === "h"
+                ? 60 * 60 * 1000
+                : 24 * 60 * 60 * 1000;
+    return Date.now() - amount * multiplier;
+}
+function buildPayloadShapeSummary(value) {
+    if (Array.isArray(value)) {
+        return {
+            argCount: value.length
+        };
+    }
+    if (!value || typeof value !== "object") {
+        return {};
+    }
+    return {
+        argKeys: Object.keys(value).sort(),
+        argCount: Object.keys(value).length
+    };
+}
+function sanitizeDetails(details) {
+    if (!details) {
+        return {};
+    }
+    const sanitized = {};
+    const shouldSkipKey = (key) => {
+        const normalized = key.replace(/[^a-z0-9]/gi, "").toLowerCase();
+        return ["body", "summary", "metadata", "token", "authorization", "artifact", "content"].some((part) => normalized.includes(part));
+    };
+    for (const [key, value] of Object.entries(details)) {
+        if (shouldSkipKey(key)) {
+            continue;
+        }
+        if (value === undefined) {
+            continue;
+        }
+        if (value === null || typeof value === "number" || typeof value === "boolean") {
+            sanitized[key] = value;
+            continue;
+        }
+        if (typeof value === "string") {
+            sanitized[key] = value.length > 200 ? `${value.slice(0, 197)}...` : value;
+            continue;
+        }
+        if (Array.isArray(value)) {
+            sanitized[key] = value
+                .filter((item) => item === null || typeof item === "string" || typeof item === "number" || typeof item === "boolean")
+                .slice(0, 20);
+            continue;
+        }
+        if (typeof value === "object") {
+            const flat = {};
+            for (const [innerKey, innerValue] of Object.entries(value)) {
+                if (shouldSkipKey(innerKey)) {
+                    continue;
+                }
+                if (innerValue === null ||
+                    typeof innerValue === "string" ||
+                    typeof innerValue === "number" ||
+                    typeof innerValue === "boolean") {
+                    flat[innerKey] = typeof innerValue === "string" && innerValue.length > 200
+                        ? `${innerValue.slice(0, 197)}...`
+                        : innerValue;
+                }
+            }
+            sanitized[key] = flat;
+        }
+    }
+    return sanitized;
+}
+export class TelemetrySpan {
+    writer;
+    state;
+    context;
+    operation;
+    startedAt = process.hrtime.bigint();
+    details;
+    finished = false;
+    constructor(writer, state, context, operation, details) {
+        this.writer = writer;
+        this.state = state;
+        this.context = context;
+        this.operation = operation;
+        this.details = sanitizeDetails(details);
+    }
+    addDetails(details) {
+        Object.assign(this.details, sanitizeDetails(details));
+    }
+    async finish(input = {}) {
+        if (this.finished) {
+            return;
+        }
+        this.finished = true;
+        const durationMs = roundDuration(Number(process.hrtime.bigint() - this.startedAt) / 1_000_000);
+        await this.writer.enqueue({
+            ts: nowIso(),
+            traceId: this.context.traceId,
+            requestId: input.requestId ?? this.context.requestId,
+            surface: this.context.surface,
+            operation: this.operation,
+            outcome: input.outcome ?? "success",
+            durationMs,
+            statusCode: input.statusCode ?? null,
+            errorCode: input.errorCode ?? null,
+            errorKind: input.errorKind ?? null,
+            workspaceName: this.state.workspaceName,
+            details: sanitizeDetails({
+                ...this.details,
+                ...input.details
+            })
+        }, this.state);
+    }
+    run(callback) {
+        return telemetryStorage.run({
+            ...this.context,
+            spans: [...this.context.spans, this]
+        }, callback);
+    }
+}
+export class ObservabilityWriter {
+    options;
+    pendingWrites = new Set();
+    retentionRuns = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    currentContext() {
+        return telemetryStorage.getStore() ?? null;
+    }
+    withContext(input, callback) {
+        return telemetryStorage.run({
+            ...input,
+            spans: []
+        }, callback);
+    }
+    startSpan(input) {
+        const state = this.options.getState();
+        const current = telemetryStorage.getStore();
+        const context = {
+            traceId: input.traceId ?? current?.traceId ?? "trace_unknown",
+            requestId: input.requestId ?? current?.requestId ?? null,
+            workspaceRoot: current?.workspaceRoot ?? state.workspaceRoot,
+            workspaceName: current?.workspaceName ?? state.workspaceName,
+            surface: input.surface ?? current?.surface ?? "api",
+            toolName: current?.toolName ?? null,
+            spans: current?.spans ?? []
+        };
+        return new TelemetrySpan(this, state, context, input.operation, input.details);
+    }
+    addCurrentSpanDetails(details) {
+        const current = telemetryStorage.getStore();
+        current?.spans[current.spans.length - 1]?.addDetails(details);
+    }
+    async recordEvent(input) {
+        const state = this.options.getState();
+        if (!state.enabled) {
+            return;
+        }
+        const current = telemetryStorage.getStore();
+        await this.enqueue({
+            ts: nowIso(),
+            traceId: input.traceId ?? current?.traceId ?? "trace_unknown",
+            requestId: input.requestId ?? current?.requestId ?? null,
+            surface: input.surface ?? current?.surface ?? "api",
+            operation: input.operation,
+            outcome: input.outcome ?? "success",
+            durationMs: input.durationMs ?? null,
+            statusCode: input.statusCode ?? null,
+            errorCode: input.errorCode ?? null,
+            errorKind: input.errorKind ?? null,
+            workspaceName: state.workspaceName,
+            details: sanitizeDetails(input.details)
+        }, state);
+    }
+    async recordError(input) {
+        await this.recordEvent({
+            ...input,
+            outcome: "error"
+        });
+    }
+    async enqueue(event, state) {
+        if (!state.enabled) {
+            return;
+        }
+        void this.pruneLogsIfNeeded(state);
+        const filePath = path.join(state.workspaceRoot, "logs", `telemetry-${dateStamp(event.ts)}.ndjson`);
+        const write = (async () => {
+            await mkdir(path.dirname(filePath), { recursive: true });
+            await appendFile(filePath, `${JSON.stringify(event)}\n`, "utf8");
+        })();
+        this.pendingWrites.add(write);
+        write.finally(() => {
+            this.pendingWrites.delete(write);
+        }).catch(() => { });
+    }
+    async flush() {
+        await Promise.allSettled([...this.pendingWrites]);
+    }
+    async pruneLogsIfNeeded(state) {
+        const retentionDays = normalizeRetentionDays(state.retentionDays);
+        const today = dateStamp(nowIso());
+        const workspaceKey = `${state.workspaceRoot}:${retentionDays}`;
+        if (this.retentionRuns.get(workspaceKey) === today) {
+            return;
+        }
+        this.retentionRuns.set(workspaceKey, today);
+        const cutoff = new Date();
+        cutoff.setUTCDate(cutoff.getUTCDate() - retentionDays);
+        const cutoffStamp = dateStamp(cutoff.toISOString());
+        const logsDir = path.join(state.workspaceRoot, "logs");
+        let entries;
+        try {
+            entries = await readdir(logsDir);
+        }
+        catch {
+            return;
+        }
+        await Promise.all(entries
+            .filter((entry) => /^telemetry-\d{4}-\d{2}-\d{2}\.ndjson$/.test(entry))
+            .filter((entry) => entry.slice("telemetry-".length, "telemetry-".length + 10) < cutoffStamp)
+            .map((entry) => unlink(path.join(logsDir, entry)).catch(() => { })));
+    }
+    async readEvents(options) {
+        const state = this.options.getState();
+        const sinceMs = parseSince(options.since);
+        const logsDir = path.join(state.workspaceRoot, "logs");
+        void this.pruneLogsIfNeeded(state);
+        let entries;
+        try {
+            entries = await readdir(logsDir);
+        }
+        catch {
+            return {
+                logsPath: logsDir,
+                events: [],
+                since: new Date(sinceMs).toISOString()
+            };
+        }
+        const files = entries
+            .filter((entry) => /^telemetry-\d{4}-\d{2}-\d{2}\.ndjson$/.test(entry))
+            .sort();
+        const events = [];
+        for (const file of files) {
+            const filePath = path.join(logsDir, file);
+            const content = await readFile(filePath, "utf8").catch(() => "");
+            for (const line of content.split("\n")) {
+                const event = parseJsonLine(line);
+                if (!event) {
+                    continue;
+                }
+                const eventMs = Date.parse(event.ts);
+                if (!Number.isFinite(eventMs) || eventMs < sinceMs) {
+                    continue;
+                }
+                if (options.surface && options.surface !== "all" && event.surface !== options.surface) {
+                    continue;
+                }
+                events.push(event);
+            }
+        }
+        return {
+            logsPath: logsDir,
+            events,
+            since: new Date(sinceMs).toISOString()
+        };
+    }
+    async summarize(options) {
+        const state = this.options.getState();
+        const { logsPath, events, since } = await this.readEvents(options);
+        const buckets = new Map();
+        const mcpFailures = new Map();
+        const autoJobs = new Map();
+        let ftsFallbackCount = 0;
+        let ftsSampleCount = 0;
+        let semanticUsedCount = 0;
+        let semanticSampleCount = 0;
+        let semanticFallbackEligibleCount = 0;
+        let semanticFallbackAttemptedCount = 0;
+        let semanticFallbackHitCount = 0;
+        for (const event of events) {
+            if (typeof event.details.ftsFallback === "boolean") {
+                ftsSampleCount += 1;
+                if (event.details.ftsFallback) {
+                    ftsFallbackCount += 1;
+                }
+            }
+            if (typeof event.details.semanticUsed === "boolean") {
+                semanticSampleCount += 1;
+                if (event.details.semanticUsed) {
+                    semanticUsedCount += 1;
+                }
+            }
+            if (typeof event.details.semanticFallbackEligible === "boolean") {
+                if (event.details.semanticFallbackEligible) {
+                    semanticFallbackEligibleCount += 1;
+                }
+            }
+            if (typeof event.details.semanticFallbackAttempted === "boolean") {
+                if (event.details.semanticFallbackAttempted) {
+                    semanticFallbackAttemptedCount += 1;
+                }
+            }
+            if (typeof event.details.semanticFallbackUsed === "boolean") {
+                if (event.details.semanticFallbackUsed) {
+                    semanticFallbackHitCount += 1;
+                }
+            }
+            if (event.durationMs != null) {
+                const bucketKey = `${event.surface}:${event.operation}`;
+                const current = buckets.get(bucketKey) ??
+                    {
+                        summary: {
+                            surface: event.surface,
+                            operation: event.operation,
+                            count: 0,
+                            errorCount: 0,
+                            errorRate: 0,
+                            avgDurationMs: null,
+                            p50DurationMs: null,
+                            p95DurationMs: null,
+                            p99DurationMs: null
+                        },
+                        durations: []
+                    };
+                current.summary.count += 1;
+                if (event.outcome === "error") {
+                    current.summary.errorCount += 1;
+                }
+                current.durations.push(event.durationMs);
+                buckets.set(bucketKey, current);
+            }
+            if (event.surface === "mcp" && event.outcome === "error") {
+                mcpFailures.set(event.operation, (mcpFailures.get(event.operation) ?? 0) + 1);
+            }
+            if (event.operation.startsWith("auto.")) {
+                const durations = autoJobs.get(event.operation) ?? [];
+                if (event.durationMs != null) {
+                    durations.push(event.durationMs);
+                }
+                autoJobs.set(event.operation, durations);
+            }
+        }
+        const operationSummaries = [...buckets.values()]
+            .map(({ summary, durations }) => {
+            const stats = percentiles(durations);
+            return {
+                ...summary,
+                errorRate: summary.count > 0 ? Number((summary.errorCount / summary.count).toFixed(4)) : 0,
+                avgDurationMs: stats.avg,
+                p50DurationMs: stats.p50,
+                p95DurationMs: stats.p95,
+                p99DurationMs: stats.p99
+            };
+        })
+            .sort((left, right) => (right.p95DurationMs ?? 0) - (left.p95DurationMs ?? 0));
+        return {
+            since,
+            generatedAt: nowIso(),
+            logsPath,
+            totalEvents: events.length,
+            operationSummaries,
+            slowOperations: operationSummaries
+                .filter((item) => (item.p95DurationMs ?? 0) >= state.slowRequestMs)
+                .slice(0, 10),
+            mcpToolFailures: [...mcpFailures.entries()]
+                .map(([operation, count]) => ({ operation, count }))
+                .sort((left, right) => right.count - left.count),
+            ftsFallbackRate: {
+                fallbackCount: ftsFallbackCount,
+                sampleCount: ftsSampleCount,
+                ratio: ftsSampleCount > 0 ? Number((ftsFallbackCount / ftsSampleCount).toFixed(4)) : null
+            },
+            semanticAugmentationRate: {
+                usedCount: semanticUsedCount,
+                sampleCount: semanticSampleCount,
+                ratio: semanticSampleCount > 0 ? Number((semanticUsedCount / semanticSampleCount).toFixed(4)) : null
+            },
+            semanticFallbackRate: {
+                eligibleCount: semanticFallbackEligibleCount,
+                attemptedCount: semanticFallbackAttemptedCount,
+                hitCount: semanticFallbackHitCount,
+                attemptRatio: semanticFallbackEligibleCount > 0
+                    ? Number((semanticFallbackAttemptedCount / semanticFallbackEligibleCount).toFixed(4))
+                    : null,
+                hitRatio: semanticFallbackAttemptedCount > 0
+                    ? Number((semanticFallbackHitCount / semanticFallbackAttemptedCount).toFixed(4))
+                    : null
+            },
+            autoJobStats: [...autoJobs.entries()].map(([operation, durations]) => ({
+                operation,
+                count: durations.length,
+                avgDurationMs: durations.length ? roundDuration(durations.reduce((sum, value) => sum + value, 0) / durations.length) : null
+            }))
+        };
+    }
+    async listErrors(options) {
+        const { logsPath, events, since } = await this.readEvents(options);
+        return {
+            since,
+            generatedAt: nowIso(),
+            surface: options.surface ?? "all",
+            logsPath,
+            items: events
+                .filter((event) => event.outcome === "error")
+                .sort((left, right) => right.ts.localeCompare(left.ts))
+                .slice(0, normalizeLimit(options.limit))
+        };
+    }
+}
+export function createObservabilityWriter(options) {
+    return new ObservabilityWriter(options);
+}
+export function currentTelemetryContext() {
+    return telemetryStorage.getStore() ?? null;
+}
+export function appendCurrentTelemetryDetails(details) {
+    const current = telemetryStorage.getStore();
+    current?.spans[current.spans.length - 1]?.addDetails(details);
+}
+export function summarizePayloadShape(value) {
+    return buildPayloadShapeSummary(value);
+}
+export function parseTelemetrySince(value) {
+    return new Date(parseSince(value)).toISOString();
+}

package/app/server/project-graph.js

@@ -0,0 +1,199 @@
+import { AppError } from "./errors.js";
+const DEFAULT_PROJECT_MEMBER_LIMIT = 120;
+const DEFAULT_PROJECT_ACTIVITY_LIMIT = 200;
+const DEFAULT_PROJECT_FALLBACK_NODE_LIMIT = 8;
+const DEFAULT_PROJECT_INFERRED_LIMIT = 60;
+function relationLabel(value) {
+    return value.replaceAll("_", " ");
+}
+export function buildProjectGraph(repository, projectId, options) {
+    const project = repository.getNode(projectId);
+    if (project.type !== "project") {
+        throw new AppError(400, "INVALID_INPUT", "Project graph only supports project nodes.");
+    }
+    const includeInferred = options?.includeInferred ?? true;
+    const memberLimit = options?.memberLimit ?? DEFAULT_PROJECT_MEMBER_LIMIT;
+    const activityLimit = options?.activityLimit ?? DEFAULT_PROJECT_ACTIVITY_LIMIT;
+    const inferredLimit = options?.maxInferred ?? DEFAULT_PROJECT_INFERRED_LIMIT;
+    const membership = repository.listProjectMemberNodes(projectId, memberLimit);
+    const scopedNodeIdSet = new Set([projectId, ...membership.map(({ node }) => node.id)]);
+    const scopedNodeIds = Array.from(scopedNodeIdSet);
+    const scopedNodes = repository.getNodesByIds(scopedNodeIds);
+    scopedNodes.set(project.id, project);
+    let canonicalEdges = repository.listRelationsBetweenNodeIds(scopedNodeIds);
+    let inferredEdges = includeInferred ? repository.listInferredRelationsBetweenNodeIds(scopedNodeIds, inferredLimit) : [];
+    const fallbackNodeIds = scopedNodeIdSet.size <= 1 && canonicalEdges.length === 0 && inferredEdges.length === 0
+        ? repository
+            .searchNodes({
+            query: "",
+            filters: {
+                types: ["note", "idea", "question", "decision", "reference", "artifact_ref"],
+                status: ["active"]
+            },
+            limit: DEFAULT_PROJECT_FALLBACK_NODE_LIMIT,
+            offset: 0,
+            sort: "updated_at"
+        })
+            .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
+            .map((nodeId) => fallbackNodeMap.get(nodeId))
+            .filter((node) => Boolean(node))
+        : [];
+    for (const node of fallbackNodes) {
+        scopedNodeIdSet.add(node.id);
+        scopedNodes.set(node.id, node);
+    }
+    if (fallbackNodes.length) {
+        const expandedScopedNodeIds = Array.from(scopedNodeIdSet);
+        canonicalEdges = repository.listRelationsBetweenNodeIds(expandedScopedNodeIds);
+        inferredEdges = includeInferred ? repository.listInferredRelationsBetweenNodeIds(expandedScopedNodeIds, inferredLimit) : [];
+    }
+    const directEdgeKeys = new Set(canonicalEdges.map((edge) => `${edge.fromNodeId}:${edge.toNodeId}`));
+    const syntheticFallbackEdges = fallbackNodes
+        .filter((node) => !directEdgeKeys.has(`${node.id}:${projectId}`) && !directEdgeKeys.has(`${projectId}:${node.id}`))
+        .map((node) => ({
+        id: `project-map-fallback:${projectId}:${node.id}`,
+        source: projectId,
+        target: node.id,
+        relationType: "related_to",
+        relationSource: "inferred",
+        status: "active",
+        score: 0.2,
+        generator: "project-map-fallback",
+        createdAt: node.updatedAt,
+        evidence: {
+            strategy: "workspace_recent",
+            reason: "Recent active workspace node used as exploratory seed because the project has no explicit membership graph yet."
+        }
+    }));
+    const allEdges = [
+        ...canonicalEdges.map((edge) => ({
+            id: edge.id,
+            source: edge.fromNodeId,
+            target: edge.toNodeId,
+            relationType: edge.relationType,
+            relationSource: "canonical",
+            status: edge.status,
+            score: null,
+            generator: null,
+            createdAt: edge.createdAt,
+            evidence: undefined,
+        })),
+        ...inferredEdges.map((edge) => ({
+            id: edge.id,
+            source: edge.fromNodeId,
+            target: edge.toNodeId,
+            relationType: edge.relationType,
+            relationSource: "inferred",
+            status: edge.status,
+            score: edge.finalScore,
+            generator: edge.generator,
+            createdAt: edge.lastComputedAt,
+            evidence: edge.evidence,
+        })),
+        ...syntheticFallbackEdges,
+    ];
+    const degreeByNodeId = new Map();
+    for (const edge of allEdges) {
+        degreeByNodeId.set(edge.source, (degreeByNodeId.get(edge.source) ?? 0) + 1);
+        degreeByNodeId.set(edge.target, (degreeByNodeId.get(edge.target) ?? 0) + 1);
+    }
+    const nodes = Array.from(scopedNodeIdSet)
+        .map((nodeId) => scopedNodes.get(nodeId))
+        .filter((node) => Boolean(node))
+        .map((node) => ({
+        id: node.id,
+        title: node.title,
+        type: node.type,
+        status: node.status,
+        canonicality: node.canonicality,
+        summary: node.summary,
+        createdAt: node.createdAt,
+        updatedAt: node.updatedAt,
+        degree: degreeByNodeId.get(node.id) ?? 0,
+        isFocus: node.id === projectId,
+        projectRole: node.id === projectId ? "focus" : "member",
+    }));
+    const nodeLabelById = new Map(nodes.map((node) => [node.id, node.title ?? node.id]));
+    const activities = repository.listActivitiesForNodeIds(Array.from(scopedNodeIdSet), activityLimit);
+    const timeline = [
+        ...nodes.map((node) => ({
+            id: `timeline-node:${node.id}`,
+            kind: "node_created",
+            at: node.createdAt,
+            nodeId: node.id,
+            label: `${node.title ?? node.id} created`,
+        })),
+        ...canonicalEdges.map((edge) => ({
+            id: `timeline-edge:${edge.id}`,
+            kind: "relation_created",
+            at: edge.createdAt,
+            edgeId: edge.id,
+            nodeId: edge.fromNodeId,
+            label: `${nodeLabelById.get(edge.fromNodeId) ?? edge.fromNodeId} ${relationLabel(edge.relationType)} ${nodeLabelById.get(edge.toNodeId) ?? edge.toNodeId}`,
+        })),
+        ...activities.map((activity) => ({
+            id: `timeline-activity:${activity.id}`,
+            kind: "activity",
+            at: activity.createdAt,
+            nodeId: activity.targetNodeId,
+            label: `${activity.activityType.replaceAll("_", " ")} on ${nodeLabelById.get(activity.targetNodeId) ?? activity.targetNodeId}`,
+        })),
+        ...syntheticFallbackEdges.map((edge) => ({
+            id: `timeline-fallback-edge:${edge.id}`,
+            kind: "relation_created",
+            at: edge.createdAt,
+            edgeId: edge.id,
+            nodeId: edge.source,
+            label: `${nodeLabelById.get(edge.source) ?? edge.source} related to ${nodeLabelById.get(edge.target) ?? edge.target}`,
+        })),
+    ];
+    timeline.sort((left, right) => {
+        const timeDelta = left.at.localeCompare(right.at);
+        if (timeDelta !== 0) {
+            return timeDelta;
+        }
+        const kindRank = kindOrder(left.kind) - kindOrder(right.kind);
+        if (kindRank !== 0) {
+            return kindRank;
+        }
+        return left.id.localeCompare(right.id);
+    });
+    const timeRange = timeline.length
+        ? {
+            start: timeline[0]?.at ?? null,
+            end: timeline[timeline.length - 1]?.at ?? null,
+        }
+        : {
+            start: project.createdAt,
+            end: project.createdAt,
+        };
+    return {
+        nodes,
+        edges: allEdges,
+        timeline,
+        meta: {
+            focusProjectId: projectId,
+            nodeCount: nodes.length,
+            edgeCount: allEdges.length,
+            inferredEdgeCount: inferredEdges.length + syntheticFallbackEdges.length,
+            timeRange,
+        },
+    };
+}
+function kindOrder(kind) {
+    switch (kind) {
+        case "node_created":
+            return 0;
+        case "relation_created":
+            return 1;
+        default:
+            return 2;
+    }
+}