preflight-mcp 0.1.2 → 0.1.3

package/dist/server.js

@@ -3,13 +3,17 @@ import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mc
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import * as z from 'zod';
 import { getConfig } from './config.js';
-import { bundleExists, checkForUpdates, clearBundleMulti, createBundle, findBundleByInputs, computeCreateInputFingerprint, findBundleStorageDir, getBundlePathsForId, getEffectiveStorageDir, listBundles, repairBundle, updateBundle, } from './bundle/service.js';
+import { checkForUpdates, clearBundleMulti, createBundle, findBundleStorageDir, getBundlePathsForId, getEffectiveStorageDir, listBundles, repairBundle, updateBundle, } from './bundle/service.js';
 import { readManifest } from './bundle/manifest.js';
 import { safeJoin, toBundleFileUri } from './mcp/uris.js';
 import { wrapPreflightError } from './mcp/errorKinds.js';
-import { searchIndex, verifyClaimInIndex } from './search/sqliteFts.js';
+import { searchIndex } from './search/sqliteFts.js';
+import { logger } from './logging/logger.js';
 import { runSearchByTags } from './tools/searchByTags.js';
 import { cleanupOnStartup, cleanupOrphanBundles } from './bundle/cleanup.js';
+import { startHttpServer } from './http/server.js';
+import { DependencyGraphInputSchema, generateDependencyGraph } from './evidence/dependencyGraph.js';
+import { TraceQueryInputSchema, TraceUpsertInputSchema, traceQuery, traceUpsert } from './trace/service.js';
 const CreateRepoInputSchema = z.union([
     z.object({
         kind: z.literal('github'),
@@ -24,10 +28,6 @@ const CreateRepoInputSchema = z.union([
         path: z.string().describe('Local directory path containing the repository files.'),
         ref: z.string().optional().describe('Optional label/ref for the local snapshot.'),
     }),
-    z.object({
-        kind: z.literal('deepwiki'),
-        url: z.string().url().describe('DeepWiki URL (https://deepwiki.com/owner/repo).'),
-    }),
 ]);
 const CreateBundleInputSchema = {
     repos: z.array(CreateRepoInputSchema).min(1).describe('Repositories to ingest into the bundle.'),
@@ -43,12 +43,6 @@ const UpdateBundleInputSchema = {
     checkOnly: z.boolean().optional().describe('If true, only check if updates are available without applying them.'),
     force: z.boolean().optional().describe('If true, force rebuild index even if no changes detected.'),
 };
-const UpdateAllBundlesInputSchema = {
-    bundleIds: z
-        .array(z.string())
-        .optional()
-        .describe('Optional bundle IDs to update. If omitted, updates all bundles in storage.'),
-};
 const SearchBundleInputSchema = {
     bundleId: z.string().describe('Bundle ID to search.'),
     query: z.string().describe('Search query. Prefix with fts: to use raw FTS syntax.'),
@@ -74,25 +68,6 @@ const SearchByTagsInputSchema = {
     scope: z.enum(['docs', 'code', 'all']).default('all').describe('Search scope.'),
     limit: z.number().int().min(1).max(200).default(50).describe('Max total hits across all bundles.'),
 };
-const VerifyClaimInputSchema = {
-    bundleId: z.string().describe('Bundle ID to verify against.'),
-    claim: z.string().describe('A claim to look for evidence for (best-effort).'),
-    scope: z.enum(['docs', 'code', 'all']).default('all').describe('Search scope.'),
-    limit: z.number().int().min(1).max(50).default(8).describe('Max number of evidence hits.'),
-    // Deprecated (kept for backward compatibility): this tool is strictly read-only.
-    ensureFresh: z
-        .boolean()
-        .optional()
-        .describe('DEPRECATED. This tool is strictly read-only and will not auto-update. Use preflight_update_bundle, then call verify again.'),
-    maxAgeHours: z
-        .number()
-        .optional()
-        .describe('DEPRECATED. Only used with ensureFresh (which is deprecated).'),
-    autoRepairIndex: z
-        .boolean()
-        .optional()
-        .describe('DEPRECATED. This tool is strictly read-only and will not auto-repair. Use preflight_repair_bundle, then call verify again.'),
-};
 const ListBundlesInputSchema = {
 // keep open for future filters
 };
@@ -106,9 +81,6 @@ const RepairBundleInputSchema = {
     rebuildGuides: z.boolean().optional().describe('If true, rebuild START_HERE.md and AGENTS.md when missing/empty.'),
     rebuildOverview: z.boolean().optional().describe('If true, rebuild OVERVIEW.md when missing/empty.'),
 };
-const BundleInfoInputSchema = {
-    bundleId: z.string().describe('Bundle ID to get info for.'),
-};
 const ReadFileInputSchema = {
     bundleId: z.string().describe('Bundle ID.'),
     file: z.string().default('OVERVIEW.md').describe('File path relative to bundle root. Common files: OVERVIEW.md, START_HERE.md, AGENTS.md, manifest.json, or any repo file like repos/owner/repo/norm/README.md'),
@@ -116,12 +88,14 @@ const ReadFileInputSchema = {
 export async function startServer() {
     const cfg = getConfig();
     // Run orphan bundle cleanup on startup (non-blocking, best-effort)
-    cleanupOnStartup(cfg).catch(() => {
-        // Errors already logged, don't block server startup
+    cleanupOnStartup(cfg).catch((err) => {
+        logger.debug('Startup cleanup failed (non-critical)', err instanceof Error ? err : undefined);
     });
+    // Start built-in REST API (best-effort). This must not interfere with MCP stdio transport.
+    startHttpServer(cfg);
     const server = new McpServer({
         name: 'preflight-mcp',
-        version: '0.1.2',
+        version: '0.1.3',
         description: 'Create evidence-based preflight bundles for repositories (docs + code) with SQLite FTS search.',
     }, {
         capabilities: {
@@ -281,7 +255,7 @@ export async function startServer() {
     });
     server.registerTool('preflight_read_file', {
         title: 'Read bundle file',
-        description: 'Read a file from bundle. Use when: "show overview", "read file", "查看概览", "项目概览", "看README", "查看文档". Common files: OVERVIEW.md, START_HERE.md, AGENTS.md.',
+        description: 'Read a file from bundle. Use when: "show overview", "read file", "查看概览", "项目概览", "看README", "查看文档", "bundle详情", "bundle状态", "仓库信息". Common files: OVERVIEW.md, START_HERE.md, AGENTS.md, manifest.json (for bundle metadata/status).',
         inputSchema: ReadFileInputSchema,
         outputSchema: {
             bundleId: z.string(),
@@ -342,131 +316,9 @@ export async function startServer() {
             throw wrapPreflightError(err);
         }
     });
-    server.registerTool('preflight_bundle_info', {
-        title: 'Bundle info',
-        description: 'Get bundle details: repos, update time, stats. Use when: "bundle info", "show bundle details", "what\'s in this bundle", "bundle状态", "查看bundle详情", "仓库信息".',
-        inputSchema: BundleInfoInputSchema,
-        outputSchema: {
-            bundleId: z.string(),
-            createdAt: z.string(),
-            updatedAt: z.string(),
-            repos: z.array(z.object({
-                kind: z.enum(['github', 'local', 'deepwiki']),
-                id: z.string(),
-                source: z.enum(['git', 'archive', 'local', 'deepwiki']).optional(),
-                headSha: z.string().optional(),
-                fetchedAt: z.string().optional(),
-                notes: z.array(z.string()).optional(),
-            })),
-            libraries: z
-                .array(z.object({
-                kind: z.literal('context7'),
-                input: z.string(),
-                id: z.string().optional(),
-                fetchedAt: z.string(),
-                notes: z.array(z.string()).optional(),
-                files: z.array(z.string()).optional(),
-            }))
-                .optional(),
-            index: z.object({
-                backend: z.string(),
-                includeDocs: z.boolean(),
-                includeCode: z.boolean(),
-            }),
-            resources: z.object({
-                startHere: z.string(),
-                agents: z.string(),
-                overview: z.string(),
-                manifest: z.string(),
-            }),
-        },
-        annotations: {
-            readOnlyHint: true,
-        },
-    }, async (args) => {
-        try {
-            const storageDir = await findBundleStorageDir(cfg.storageDirs, args.bundleId);
-            if (!storageDir) {
-                throw new Error(`Bundle not found: ${args.bundleId}`);
-            }
-            const paths = getBundlePathsForId(storageDir, args.bundleId);
-            const manifest = await readManifest(paths.manifestPath);
-            const resources = {
-                startHere: toBundleFileUri({ bundleId: args.bundleId, relativePath: 'START_HERE.md' }),
-                agents: toBundleFileUri({ bundleId: args.bundleId, relativePath: 'AGENTS.md' }),
-                overview: toBundleFileUri({ bundleId: args.bundleId, relativePath: 'OVERVIEW.md' }),
-                manifest: toBundleFileUri({ bundleId: args.bundleId, relativePath: 'manifest.json' }),
-            };
-            const out = {
-                bundleId: manifest.bundleId,
-                createdAt: manifest.createdAt,
-                updatedAt: manifest.updatedAt,
-                repos: manifest.repos,
-                libraries: manifest.libraries,
-                index: manifest.index,
-                resources,
-            };
-            return {
-                content: [{ type: 'text', text: JSON.stringify(out, null, 2) }],
-                structuredContent: out,
-            };
-        }
-        catch (err) {
-            throw wrapPreflightError(err);
-        }
-    });
-    server.registerTool('preflight_find_bundle', {
-        title: 'Find existing bundle',
-        description: 'Check whether a bundle already exists for the given inputs (no fetching, no changes). Use when: "does this repo already exist", "have I indexed this", "find bundle for", "这个项目是否已索引".',
-        inputSchema: {
-            repos: z.array(CreateRepoInputSchema).min(1),
-            libraries: z.array(z.string()).optional(),
-            topics: z.array(z.string()).optional(),
-        },
-        outputSchema: {
-            found: z.boolean(),
-            bundleId: z.string().optional(),
-            fingerprint: z.string(),
-        },
-        annotations: {
-            readOnlyHint: true,
-        },
-    }, async (args) => {
-        try {
-            const fingerprint = computeCreateInputFingerprint({
-                repos: args.repos,
-                libraries: args.libraries,
-                topics: args.topics,
-            });
-            const bundleId = await findBundleByInputs(cfg, {
-                repos: args.repos,
-                libraries: args.libraries,
-                topics: args.topics,
-            });
-            const out = {
-                found: !!bundleId,
-                bundleId: bundleId ?? undefined,
-                fingerprint,
-            };
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: out.found
-                            ? `FOUND ${out.bundleId} (fingerprint=${out.fingerprint})`
-                            : `NOT_FOUND (fingerprint=${out.fingerprint})`,
-                    },
-                ],
-                structuredContent: out,
-            };
-        }
-        catch (err) {
-            throw wrapPreflightError(err);
-        }
-    });
     server.registerTool('preflight_create_bundle', {
         title: 'Create bundle',
-        description: 'Create a new bundle from GitHub repos or DeepWiki (or update an existing one if ifExists=updateExisting). Use when: "index this repo", "create bundle for", "add repo to preflight", "索引这个仓库", "创建bundle", "添加GitHub项目", "学习这个项目".',
+        description: 'Create a new bundle from GitHub repos or local directories (or update an existing one if ifExists=updateExisting). Use when: "index this repo", "create bundle for", "add repo to preflight", "索引这个仓库", "创建bundle", "添加GitHub项目", "学习这个项目". NOTE: If the bundle contains code files, consider asking user if they want to generate dependency graph (preflight_evidence_dependency_graph) or establish trace links (preflight_trace_upsert).',
         inputSchema: CreateBundleInputSchema,
         outputSchema: {
             bundleId: z.string(),
@@ -479,9 +331,9 @@ export async function startServer() {
                 manifest: z.string(),
             }),
             repos: z.array(z.object({
-                kind: z.enum(['github', 'local', 'deepwiki']),
+                kind: z.enum(['github', 'local']),
                 id: z.string(),
-                source: z.enum(['git', 'archive', 'local', 'deepwiki']).optional(),
+                source: z.enum(['git', 'archive', 'local']).optional(),
                 headSha: z.string().optional(),
                 notes: z.array(z.string()).optional(),
             })),
@@ -655,52 +507,6 @@ export async function startServer() {
             throw wrapPreflightError(err);
         }
     });
-    server.registerTool('preflight_update_all_bundles', {
-        title: 'Update all bundles',
-        description: 'Batch update all bundles at once. Use when: "update all bundles", "refresh everything", "sync all", "批量更新", "全部刷新", "更新所有bundle".',
-        inputSchema: UpdateAllBundlesInputSchema,
-        outputSchema: {
-            total: z.number().int(),
-            ok: z.number().int(),
-            results: z.array(z.object({
-                bundleId: z.string(),
-                changed: z.boolean().optional(),
-                updatedAt: z.string().optional(),
-                error: z.string().optional(),
-            })),
-        },
-        annotations: {
-            openWorldHint: true,
-        },
-    }, async (args) => {
-        const effectiveDir = await getEffectiveStorageDir(cfg);
-        const ids = args.bundleIds && args.bundleIds.length > 0
-            ? args.bundleIds
-            : await listBundles(effectiveDir);
-        const results = [];
-        for (const bundleId of ids) {
-            try {
-                const exists = await bundleExists(effectiveDir, bundleId);
-                if (!exists) {
-                    throw new Error(`Bundle not found: ${bundleId}`);
-                }
-                const { summary, changed } = await updateBundle(cfg, bundleId);
-                results.push({ bundleId, changed, updatedAt: summary.updatedAt });
-            }
-            catch (err) {
-                results.push({ bundleId, error: wrapPreflightError(err).message });
-            }
-        }
-        const out = {
-            total: ids.length,
-            ok: results.filter((r) => !r.error).length,
-            results,
-        };
-        return {
-            content: [{ type: 'text', text: JSON.stringify(out, null, 2) }],
-            structuredContent: out,
-        };
-    });
     server.registerTool('preflight_search_by_tags', {
         title: 'Search by tags',
         description: 'Search across multiple bundles filtered by tags. Use when: "search in MCP bundles", "find in all agent repos", "search web-scraping tools", "在MCP项目中搜索", "搜索所有agent".',
@@ -749,7 +555,7 @@ export async function startServer() {
             },
             searchIndexForBundleId: (bundleId, query, scope, limit) => {
                 const paths = getBundlePathsForId(effectiveDir, bundleId);
-                return searchIndex(paths.searchDbPath, query, scope, limit);
+                return searchIndex(paths.searchDbPath, query, scope, limit, paths.rootDir);
             },
             toUri: (bundleId, p) => toBundleFileUri({ bundleId, relativePath: p }),
         });
@@ -815,7 +621,7 @@ export async function startServer() {
                     'Call preflight_repair_bundle explicitly, then call preflight_search_bundle again.');
             }
             const paths = getBundlePathsForId(storageDir, args.bundleId);
-            const rawHits = searchIndex(paths.searchDbPath, args.query, args.scope, args.limit);
+            const rawHits = searchIndex(paths.searchDbPath, args.query, args.scope, args.limit, paths.rootDir);
             const hits = rawHits.map((h) => ({
                 ...h,
                 uri: toBundleFileUri({ bundleId: args.bundleId, relativePath: h.path }),
@@ -835,98 +641,81 @@ export async function startServer() {
             throw wrapPreflightError(err);
         }
     });
-    server.registerTool('preflight_verify_claim', {
-        title: 'Verify claim',
-        description: 'Verify a claim with evidence classification and confidence scoring (strictly read-only). If you need to update or repair, call preflight_update_bundle or preflight_repair_bundle explicitly, then verify again. Returns supporting/contradicting/related evidence. Use when: "verify this claim", "is this true", "find evidence for", "check if", "验证说法", "找证据", "这个对吗", "有没有依据".',
-        inputSchema: VerifyClaimInputSchema,
+    server.registerTool('preflight_evidence_dependency_graph', {
+        title: 'Evidence: dependency graph (callers + imports)',
+        description: 'Generate an evidence-based dependency graph for a target file/symbol inside a bundle. Output is deterministic (FTS + regex) and every edge includes traceable sources (file + range). This tool is read-only.',
+        inputSchema: DependencyGraphInputSchema,
         outputSchema: {
-            bundleId: z.string(),
-            claim: z.string(),
-            scope: z.enum(['docs', 'code', 'all']),
-            found: z.boolean(),
-            confidence: z.number().describe('Confidence score 0-1'),
-            confidenceLabel: z.enum(['high', 'medium', 'low', 'none']),
-            summary: z.string().describe('Human-readable summary of verification'),
-            supporting: z.array(z.object({
-                kind: z.enum(['doc', 'code']),
-                repo: z.string(),
-                path: z.string(),
-                lineNo: z.number(),
-                snippet: z.string(),
-                uri: z.string(),
-                evidenceType: z.enum(['supporting', 'contradicting', 'related']),
-                relevanceScore: z.number(),
-            })).describe('Evidence supporting the claim'),
-            contradicting: z.array(z.object({
-                kind: z.enum(['doc', 'code']),
-                repo: z.string(),
-                path: z.string(),
-                lineNo: z.number(),
-                snippet: z.string(),
-                uri: z.string(),
-                evidenceType: z.enum(['supporting', 'contradicting', 'related']),
-                relevanceScore: z.number(),
-            })).describe('Evidence contradicting the claim'),
-            related: z.array(z.object({
-                kind: z.enum(['doc', 'code']),
-                repo: z.string(),
-                path: z.string(),
-                lineNo: z.number(),
-                snippet: z.string(),
-                uri: z.string(),
-                evidenceType: z.enum(['supporting', 'contradicting', 'related']),
-                relevanceScore: z.number(),
-            })).describe('Related but inconclusive evidence'),
-            autoUpdated: z
-                .boolean()
-                .optional()
-                .describe('DEPRECATED. This tool is strictly read-only and will not auto-update.'),
-            autoRepaired: z
-                .boolean()
-                .optional()
-                .describe('DEPRECATED. This tool is strictly read-only and will not auto-repair.'),
-            repairActions: z
-                .array(z.string())
-                .optional()
-                .describe('DEPRECATED. This tool is strictly read-only and will not auto-repair.'),
+            meta: z.any(),
+            facts: z.any(),
+            signals: z.any(),
         },
         annotations: {
             readOnlyHint: true,
         },
     }, async (args) => {
         try {
-            // Resolve bundle location across storageDirs (more robust than a single effectiveDir).
-            const storageDir = await findBundleStorageDir(cfg.storageDirs, args.bundleId);
-            if (!storageDir) {
-                throw new Error(`Bundle not found: ${args.bundleId}`);
-            }
-            if (args.ensureFresh) {
-                throw new Error('ensureFresh is deprecated and not supported in this tool. This tool is strictly read-only. ' +
-                    'Call preflight_update_bundle explicitly, then call preflight_verify_claim again.');
-            }
-            if (args.autoRepairIndex) {
-                throw new Error('autoRepairIndex is deprecated and not supported in this tool. This tool is strictly read-only. ' +
-                    'Call preflight_repair_bundle explicitly, then call preflight_verify_claim again.');
-            }
-            const paths = getBundlePathsForId(storageDir, args.bundleId);
-            const verification = verifyClaimInIndex(paths.searchDbPath, args.claim, args.scope, args.limit);
-            // Add URIs to evidence hits
-            const addUri = (hit) => ({
-                ...hit,
-                uri: toBundleFileUri({ bundleId: args.bundleId, relativePath: hit.path }),
-            });
-            const out = {
-                bundleId: args.bundleId,
-                claim: args.claim,
-                scope: args.scope,
-                found: verification.found,
-                confidence: verification.confidence,
-                confidenceLabel: verification.confidenceLabel,
-                summary: verification.summary,
-                supporting: verification.supporting.map(addUri),
-                contradicting: verification.contradicting.map(addUri),
-                related: verification.related.map(addUri),
+            const out = await generateDependencyGraph(cfg, args);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(out, null, 2) }],
+                structuredContent: out,
             };
+        }
+        catch (err) {
+            throw wrapPreflightError(err);
+        }
+    });
+    server.registerTool('preflight_trace_upsert', {
+        title: 'Trace: upsert links',
+        description: 'Upsert traceability links (commit↔ticket, symbol↔test, code↔doc, etc.) for a bundle. Stores trace edges in a per-bundle SQLite database.',
+        inputSchema: TraceUpsertInputSchema,
+        outputSchema: {
+            bundleId: z.string(),
+            upserted: z.number().int(),
+            ids: z.array(z.string()),
+        },
+        annotations: {
+            openWorldHint: true,
+        },
+    }, async (args) => {
+        try {
+            const out = await traceUpsert(cfg, args);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(out, null, 2) }],
+                structuredContent: out,
+            };
+        }
+        catch (err) {
+            throw wrapPreflightError(err);
+        }
+    });
+    server.registerTool('preflight_trace_query', {
+        title: 'Trace: query links',
+        description: 'Query traceability links. Provide bundleId for fast queries; if omitted, scans across bundles (capped). This tool is read-only.',
+        inputSchema: TraceQueryInputSchema,
+        outputSchema: {
+            bundleId: z.string().optional(),
+            scannedBundles: z.number().int().optional(),
+            truncated: z.boolean().optional(),
+            edges: z.array(z.object({
+                id: z.string(),
+                source: z.object({ type: z.string(), id: z.string() }),
+                target: z.object({ type: z.string(), id: z.string() }),
+                type: z.string(),
+                confidence: z.number(),
+                method: z.enum(['exact', 'heuristic']),
+                sources: z.array(z.any()),
+                createdAt: z.string(),
+                updatedAt: z.string(),
+                bundleId: z.string().optional(),
+            })),
+        },
+        annotations: {
+            readOnlyHint: true,
+        },
+    }, async (args) => {
+        try {
+            const out = await traceQuery(cfg, args);
             return {
                 content: [{ type: 'text', text: JSON.stringify(out, null, 2) }],
                 structuredContent: out,

package/dist/trace/service.js

@@ -0,0 +1,108 @@
+import path from 'node:path';
+import * as z from 'zod';
+import { findBundleStorageDir, getBundlePathsForId, listBundlesMulti } from '../bundle/service.js';
+import { ensureTraceDb, queryTraceEdges, upsertTraceEdges } from './store.js';
+export const TraceUpsertInputSchema = {
+    bundleId: z.string().describe('Bundle ID to attach trace links to.'),
+    edges: z
+        .array(z.object({
+        id: z.string().optional(),
+        source: z.object({ type: z.string(), id: z.string() }),
+        target: z.object({ type: z.string(), id: z.string() }),
+        type: z.string().describe('Edge type, e.g. mentions/tests/implements/relates_to'),
+        confidence: z.number().min(0).max(1).optional(),
+        method: z.enum(['exact', 'heuristic']).optional(),
+        sources: z
+            .array(z.object({
+            file: z.string().optional(),
+            range: z
+                .object({
+                startLine: z.number().int().min(1),
+                startCol: z.number().int().min(1),
+                endLine: z.number().int().min(1),
+                endCol: z.number().int().min(1),
+            })
+                .optional(),
+            externalUrl: z.string().optional(),
+            note: z.string().optional(),
+        }))
+            .optional(),
+    }))
+        .min(1)
+        .describe('Trace edges to upsert.'),
+};
+export const TraceQueryInputSchema = {
+    // When omitted, the query may scan across bundles (best-effort, capped).
+    bundleId: z.string().optional().describe('Optional bundleId. If omitted, scans across bundles (capped).'),
+    source_type: z.string(),
+    source_id: z.string(),
+    target_type: z.string().optional(),
+    target_id: z.string().optional(),
+    edge_type: z.string().optional(),
+    limit: z.number().int().min(1).max(500).default(50),
+    timeBudgetMs: z.number().int().min(500).max(30_000).default(5_000),
+    maxBundles: z.number().int().min(1).max(200).default(50),
+};
+function traceDbPathForBundleRoot(bundleRoot) {
+    return path.join(bundleRoot, 'trace', 'trace.sqlite3');
+}
+async function getTraceDbPathForBundleId(cfg, bundleId) {
+    const storageDir = await findBundleStorageDir(cfg.storageDirs, bundleId);
+    if (!storageDir) {
+        throw new Error(`Bundle not found: ${bundleId}`);
+    }
+    const paths = getBundlePathsForId(storageDir, bundleId);
+    const traceDbPath = traceDbPathForBundleRoot(paths.rootDir);
+    await ensureTraceDb(traceDbPath);
+    return traceDbPath;
+}
+export async function traceUpsert(cfg, rawArgs) {
+    const args = z.object(TraceUpsertInputSchema).parse(rawArgs);
+    const traceDbPath = await getTraceDbPathForBundleId(cfg, args.bundleId);
+    const res = await upsertTraceEdges(traceDbPath, args.edges);
+    return { bundleId: args.bundleId, ...res };
+}
+export async function traceQuery(cfg, rawArgs) {
+    const args = z.object(TraceQueryInputSchema).parse(rawArgs);
+    const source = { type: args.source_type, id: args.source_id };
+    const target = args.target_type && args.target_id ? { type: args.target_type, id: args.target_id } : undefined;
+    // Fast path: single bundle
+    if (args.bundleId) {
+        const dbPath = await getTraceDbPathForBundleId(cfg, args.bundleId);
+        const rows = queryTraceEdges(dbPath, { source, target, edgeType: args.edge_type, limit: args.limit });
+        return { bundleId: args.bundleId, edges: rows };
+    }
+    // Slow path: scan across bundles (best-effort, capped)
+    const startedAt = Date.now();
+    const timeLeft = () => args.timeBudgetMs - (Date.now() - startedAt);
+    let truncated = false;
+    const bundleIds = (await listBundlesMulti(cfg.storageDirs)).slice(0, args.maxBundles);
+    const collected = [];
+    for (const bundleId of bundleIds) {
+        if (timeLeft() <= 0) {
+            truncated = true;
+            break;
+        }
+        try {
+            const dbPath = await getTraceDbPathForBundleId(cfg, bundleId);
+            const rows = queryTraceEdges(dbPath, { source, target, edgeType: args.edge_type, limit: Math.min(50, args.limit) });
+            for (const r of rows) {
+                collected.push({ ...r, bundleId });
+                if (collected.length >= args.limit)
+                    break;
+            }
+        }
+        catch {
+            // ignore bundles without trace
+        }
+        if (collected.length >= args.limit)
+            break;
+    }
+    // Sort by updatedAt desc across bundles
+    collected.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    return {
+        scannedBundles: bundleIds.length,
+        truncated: truncated ? true : undefined,
+        edges: collected.slice(0, args.limit),
+    };
+}