gitnexus 1.6.10-rc.98 → 1.6.10

package/dist/core/wiki/graph-queries.js

@@ -4,8 +4,15 @@
  * Encapsulated Cypher queries against the GitNexus knowledge graph.
  * Uses the MCP-style pooled lbug-adapter for connection management.
  */
-import { initLbug, executeQuery, closeLbug, touchRepo, pinRepo } from '../lbug/pool-adapter.js';
-import { escapeCypherString } from '../lbug/cypher-escape.js';
+import { initLbug, executeQuery, executeParameterized, closeLbug, touchRepo, pinRepo, } from '../lbug/pool-adapter.js';
+/**
+ * Rows kept by each call-edge query. Owned by prompts.ts, where the reason for
+ * a limit lives: every one of these lists reaches the LLM through
+ * `formatCallEdges`, which slices to the same value. Fetching rows that slice
+ * would discard is waste, so the cut happens here too — but as the same number,
+ * not a second one, because a second one could only ever drift from it.
+ */
+import { CALL_EDGE_LIMIT } from './prompts.js';
 const REPO_ID = '__wiki__';
 /**
  * Touch the wiki DB connection to prevent idle timeout during long LLM calls.
@@ -21,6 +28,74 @@ export function touchWikiDb() {
 export function pinWikiDb() {
     return pinRepo(REPO_ID);
 }
+function toCallEdge(row) {
+    return {
+        fromFile: row.fromFile,
+        fromName: row.fromName,
+        toFile: row.toFile,
+        toName: row.toName,
+    };
+}
+// The defaults below use `??`, not `||`: only an absent property falls back, so
+// a process genuinely labelled '' or a step numbered 0 keeps its own value.
+function toProcessHeader(row) {
+    const id = row.id;
+    return {
+        id,
+        label: row.label ?? id,
+        type: row.type ?? 'unknown',
+        stepCount: row.stepCount ?? 0,
+    };
+}
+function toProcessStep(row) {
+    return {
+        step: row.step ?? 0,
+        name: row.name,
+        filePath: row.filePath,
+        type: row.type,
+    };
+}
+/**
+ * Attach each header's full step trace, in one query for the whole set.
+ *
+ * One query per process cost 105ms for 20 processes against this repo's index;
+ * grouping them on `p.id IN $ids` costs 13ms. `stepsById` below does the
+ * grouping, so the rows need not arrive grouped — only in step order.
+ *
+ * `ORDER BY step`, and deliberately not `ORDER BY pid, step`: leading the sort
+ * with the same property the `IN` list matches on makes the engine stop after
+ * that key, and the trace comes back in insertion order (2,7,1,3,4,5,6 for
+ * `proc_1_incrementalupdate` on this repo's index). The identical query with
+ * `p.id = '…'` sorts fine, as does this one — a global sort by `step` keeps
+ * each process's own rows ascending, which is all the grouping needs.
+ *
+ * `labels(s)`, not `labels(s)[0]`: the engine returns a node's label as a
+ * scalar string, and subscripting a string is 1-based over its characters, so
+ * `[0]` was always '' and `[1]` would have been 'F'. Verified against this
+ * repo's index — `labels(s)` yields 'Function'.
+ */
+async function withSteps(headers) {
+    if (headers.length === 0)
+        return [];
+    const stepRows = await executeParameterized(REPO_ID, `
+      MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
+      WHERE p.id IN $ids
+      RETURN p.id AS pid, s.name AS name, s.filePath AS filePath,
+             labels(s) AS type, r.step AS step
+      ORDER BY step
+    `, { ids: headers.map((header) => header.id) });
+    const stepsById = new Map();
+    for (const row of stepRows) {
+        const pid = String(row.pid);
+        let steps = stepsById.get(pid);
+        if (!steps) {
+            steps = [];
+            stepsById.set(pid, steps);
+        }
+        steps.push(toProcessStep(row));
+    }
+    return headers.map((header) => ({ ...header, steps: stepsById.get(header.id) ?? [] }));
+}
 /**
  * Initialize the LadybugDB connection for wiki generation.
  */
@@ -40,28 +115,28 @@ export async function closeWikiDb() {
  * longer have a direct File→DEFINES edge.
  */
 export async function getFilesWithExports() {
+    // `labels(n)`, not `labels(n)[0]` — see withSteps. `prompts.ts` renders this
+    // type as `name (type)`, so the subscript printed every symbol as `name ()`.
     const rows = await executeQuery(REPO_ID, `
     MATCH (f:File)-[:CodeRelation {type: 'DEFINES'}]->(n)
     WHERE n.isExported = true
-    RETURN f.filePath AS filePath, n.name AS name, labels(n)[0] AS type
+    RETURN f.filePath AS filePath, n.name AS name, labels(n) AS type
     UNION
     MATCH (f:File)-[:CodeRelation {type: 'DEFINES'}]->(c)
           -[mr:CodeRelation]->(n)
     WHERE mr.type IN ['HAS_METHOD', 'HAS_PROPERTY'] AND n.isExported = true
-    RETURN f.filePath AS filePath, n.name AS name, labels(n)[0] AS type
+    RETURN f.filePath AS filePath, n.name AS name, labels(n) AS type
     ORDER BY filePath
   `);
     const fileMap = new Map();
     for (const row of rows) {
-        const fp = row.filePath || row[0];
-        const name = row.name || row[1];
-        const type = row.type || row[2];
-        let entry = fileMap.get(fp);
+        const filePath = row.filePath;
+        let entry = fileMap.get(filePath);
         if (!entry) {
-            entry = { filePath: fp, symbols: [] };
-            fileMap.set(fp, entry);
+            entry = { filePath, symbols: [] };
+            fileMap.set(filePath, entry);
         }
-        entry.symbols.push({ name, type });
+        entry.symbols.push({ name: row.name, type: row.type });
     }
     return Array.from(fileMap.values());
 }
@@ -74,7 +149,7 @@ export async function getAllFiles() {
     RETURN f.filePath AS filePath
     ORDER BY f.filePath
   `);
-    return rows.map((r) => r.filePath || r[0]);
+    return rows.map((row) => row.filePath);
 }
 /**
  * Get inter-file call edges (calls between different files).
@@ -86,12 +161,7 @@ export async function getInterFileCallEdges() {
     RETURN DISTINCT a.filePath AS fromFile, a.name AS fromName,
            b.filePath AS toFile, b.name AS toName
   `);
-    return rows.map((r) => ({
-        fromFile: r.fromFile || r[0],
-        fromName: r.fromName || r[1],
-        toFile: r.toFile || r[2],
-        toName: r.toName || r[3],
-    }));
+    return rows.map(toCallEdge);
 }
 /**
  * Get call edges between files within a specific set (intra-module).
@@ -99,19 +169,32 @@ export async function getInterFileCallEdges() {
 export async function getIntraModuleCallEdges(filePaths) {
     if (filePaths.length === 0)
         return [];
-    const fileList = filePaths.map((f) => `'${escapeCypherString(f)}'`).join(', ');
-    const rows = await executeQuery(REPO_ID, `
+    // The file list is BOUND, not spliced into the query text. A module can hold
+    // every file under a parent, so an `IN [...]` literal would grow the query
+    // with the repo — the shape that crashed the engine in #2915 (see
+    // `coalesceHunks` in src/storage/git.ts). As a parameter the text is constant
+    // at any list length, and measured ~3x faster than the equivalent literal, so
+    // both arms of the predicate can stay in Cypher where the engine can use them.
+    // Ordered and cut in Cypher, like getInterModuleCallEdges below and for the
+    // same two reasons. Determinism: the original had no ORDER BY, so the engine's
+    // arbitrary order decided which 30 `formatCallEdges` (prompts.ts) kept, and
+    // the cut landed on a different subset per machine (#2787). Volume: a root
+    // parent page passes every file under it, i.e. the whole repo — over 2298
+    // paths this query returned 18299 rows in 1064ms to use 30 of them, against
+    // 30 rows in 97ms with the LIMIT below, same leading rows.
+    //
+    // The engine orders by UTF-8 bytes where the JS sort this replaces compared
+    // UTF-16 code units — identical for ASCII identifiers, divergent only above
+    // the BMP, and the sibling already relies on the engine, so the two agree.
+    const rows = await executeParameterized(REPO_ID, `
     MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b)
-    WHERE a.filePath IN [${fileList}] AND b.filePath IN [${fileList}]
+    WHERE a.filePath IN $paths AND b.filePath IN $paths
     RETURN DISTINCT a.filePath AS fromFile, a.name AS fromName,
            b.filePath AS toFile, b.name AS toName
-  `);
-    return rows.map((r) => ({
-        fromFile: r.fromFile || r[0],
-        fromName: r.fromName || r[1],
-        toFile: r.toFile || r[2],
-        toName: r.toName || r[3],
-    }));
+    ORDER BY fromName, toName, fromFile, toFile
+    LIMIT ${CALL_EDGE_LIMIT}
+  `, { paths: filePaths });
+    return rows.map(toCallEdge);
 }
 /**
  * Get call edges crossing module boundaries (external calls from/to module files).
@@ -119,35 +202,34 @@ export async function getIntraModuleCallEdges(filePaths) {
 export async function getInterModuleCallEdges(filePaths) {
     if (filePaths.length === 0)
         return { outgoing: [], incoming: [] };
-    const fileList = filePaths.map((f) => `'${escapeCypherString(f)}'`).join(', ');
-    const outRows = await executeQuery(REPO_ID, `
-    MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b)
-    WHERE a.filePath IN [${fileList}] AND NOT b.filePath IN [${fileList}]
-    RETURN DISTINCT a.filePath AS fromFile, a.name AS fromName,
-           b.filePath AS toFile, b.name AS toName
-    LIMIT 30
-  `);
-    const inRows = await executeQuery(REPO_ID, `
+    // Bound list, as in getIntraModuleCallEdges — which also keeps the `NOT ...
+    // IN` arm honest: `NOT null IN [...]` is null, so a callee with no filePath
+    // is dropped by the engine, where a JS membership test would admit it.
+    //
+    // The sort leads with the symbol names, not the file paths. Ordering by
+    // `fromFile` first makes the LIMIT a single-file prefix — on this repo's own
+    // index the 30 outgoing edges of `core/wiki` all came from 1 of its 7 files,
+    // so the module page described one file's external surface as the module's.
+    // The four columns are the whole DISTINCT tuple, so any permutation is a
+    // total order and equally deterministic (#2787); leading with the names just
+    // spreads the window across files (1 → 7 of 7 here).
+    const edgeQuery = (membership) => `
     MATCH (a)-[:CodeRelation {type: 'CALLS'}]->(b)
-    WHERE NOT a.filePath IN [${fileList}] AND b.filePath IN [${fileList}]
+    WHERE ${membership}
     RETURN DISTINCT a.filePath AS fromFile, a.name AS fromName,
            b.filePath AS toFile, b.name AS toName
-    LIMIT 30
-  `);
-    return {
-        outgoing: outRows.map((r) => ({
-            fromFile: r.fromFile || r[0],
-            fromName: r.fromName || r[1],
-            toFile: r.toFile || r[2],
-            toName: r.toName || r[3],
-        })),
-        incoming: inRows.map((r) => ({
-            fromFile: r.fromFile || r[0],
-            fromName: r.fromName || r[1],
-            toFile: r.toFile || r[2],
-            toName: r.toName || r[3],
-        })),
-    };
+    ORDER BY fromName, toName, fromFile, toFile
+    LIMIT ${CALL_EDGE_LIMIT}
+  `;
+    const [outRows, inRows] = await Promise.all([
+        executeParameterized(REPO_ID, edgeQuery('a.filePath IN $paths AND NOT b.filePath IN $paths'), {
+            paths: filePaths,
+        }),
+        executeParameterized(REPO_ID, edgeQuery('NOT a.filePath IN $paths AND b.filePath IN $paths'), {
+            paths: filePaths,
+        }),
+    ]);
+    return { outgoing: outRows.map(toCallEdge), incoming: inRows.map(toCallEdge) };
 }
 /**
  * Get processes (execution flows) that pass through a set of files.
@@ -156,42 +238,17 @@ export async function getInterModuleCallEdges(filePaths) {
 export async function getProcessesForFiles(filePaths, limit = 5) {
     if (filePaths.length === 0)
         return [];
-    const fileList = filePaths.map((f) => `'${escapeCypherString(f)}'`).join(', ');
-    // Find processes that have steps in the given files
-    const procRows = await executeQuery(REPO_ID, `
+    // Bound list, as in getIntraModuleCallEdges, so `LIMIT` can stay in Cypher
+    // over the whole set instead of being applied per batch and re-merged.
+    const procRows = await executeParameterized(REPO_ID, `
     MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
-    WHERE s.filePath IN [${fileList}]
+    WHERE s.filePath IN $paths
     RETURN DISTINCT p.id AS id, p.heuristicLabel AS label,
            p.processType AS type, p.stepCount AS stepCount
-    ORDER BY stepCount DESC
+    ORDER BY stepCount DESC, id
     LIMIT ${limit}
-  `);
-    const processes = [];
-    for (const row of procRows) {
-        const procId = row.id || row[0];
-        const label = row.label || row[1] || procId;
-        const type = row.type || row[2] || 'unknown';
-        const stepCount = row.stepCount || row[3] || 0;
-        // Get the full step trace for this process
-        const stepRows = await executeQuery(REPO_ID, `
-      MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process {id: '${escapeCypherString(procId)}'})
-      RETURN s.name AS name, s.filePath AS filePath, labels(s)[0] AS type, r.step AS step
-      ORDER BY r.step
-    `);
-        processes.push({
-            id: procId,
-            label,
-            type,
-            stepCount,
-            steps: stepRows.map((s) => ({
-                step: s.step || s[3] || 0,
-                name: s.name || s[0],
-                filePath: s.filePath || s[1],
-                type: s.type || s[2],
-            })),
-        });
-    }
-    return processes;
+  `, { paths: filePaths });
+    return withSteps(procRows.map(toProcessHeader));
 }
 /**
  * Get all processes in the graph (for overview page).
@@ -201,34 +258,10 @@ export async function getAllProcesses(limit = 20) {
     MATCH (p:Process)
     RETURN p.id AS id, p.heuristicLabel AS label,
            p.processType AS type, p.stepCount AS stepCount
-    ORDER BY stepCount DESC
+    ORDER BY stepCount DESC, id
     LIMIT ${limit}
   `);
-    const processes = [];
-    for (const row of procRows) {
-        const procId = row.id || row[0];
-        const label = row.label || row[1] || procId;
-        const type = row.type || row[2] || 'unknown';
-        const stepCount = row.stepCount || row[3] || 0;
-        const stepRows = await executeQuery(REPO_ID, `
-      MATCH (s)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process {id: '${escapeCypherString(procId)}'})
-      RETURN s.name AS name, s.filePath AS filePath, labels(s)[0] AS type, r.step AS step
-      ORDER BY r.step
-    `);
-        processes.push({
-            id: procId,
-            label,
-            type,
-            stepCount,
-            steps: stepRows.map((s) => ({
-                step: s.step || s[3] || 0,
-                name: s.name || s[0],
-                filePath: s.filePath || s[1],
-                type: s.type || s[2],
-            })),
-        });
-    }
-    return processes;
+    return withSteps(procRows.map(toProcessHeader));
 }
 /**
  * Get inter-module edges for overview architecture diagram.

package/dist/core/wiki/llm-client.d.ts

@@ -2,11 +2,36 @@
  * LLM Client for Wiki Generation
  *
  * OpenAI-compatible API client using native fetch.
- * Supports OpenAI, Azure, LiteLLM, Ollama, and any OpenAI-compatible endpoint.
+ * Supports MiniMax and other OpenAI-compatible endpoints.
  *
  * Config priority: CLI flags > env vars > defaults
  */
-export type LLMProvider = 'openai' | 'openrouter' | 'azure' | 'custom' | 'cursor' | 'claude' | 'codex' | 'opencode';
+export type LLMProvider = 'openai' | 'openrouter' | 'azure' | 'custom' | 'cursor' | 'claude' | 'codex' | 'opencode' | 'minimax';
+export declare const MINIMAX_OPENAI_BASE_URLS: {
+    readonly global_en: "https://api.minimax.io/v1";
+    readonly cn_zh: "https://api.minimaxi.com/v1";
+};
+export declare const MINIMAX_MODEL_IDS: readonly ["MiniMax-M3", "MiniMax-M2.7"];
+export type MiniMaxThinkingMode = 'adaptive' | 'disabled' | 'always_on';
+export type LLMUserContent = string | Array<{
+    type: 'text';
+    text: string;
+} | {
+    type: 'image_url';
+    image_url: {
+        url: string;
+        detail?: 'low' | 'default' | 'high';
+        max_long_side_pixel?: number;
+    };
+} | {
+    type: 'video_url';
+    video_url: {
+        url: string;
+        detail?: 'low' | 'default' | 'high';
+        fps?: number;
+        max_long_side_pixel?: number;
+    };
+}>;
 export interface LLMConfig {
     apiKey: string;
     baseUrl: string;
@@ -31,6 +56,7 @@ export interface LLMResponse {
     promptTokens?: number;
     completionTokens?: number;
 }
+export declare function resolveMiniMaxThinkingMode(model: string, reasoningOverride?: boolean): MiniMaxThinkingMode | undefined;
 /**
  * Resolve LLM configuration from env vars, saved config, and optional overrides.
  * Priority: overrides (CLI flags) > env vars > ~/.gitnexus/config.json > error
@@ -86,4 +112,4 @@ export interface CallLLMOptions {
  * Uses streaming when onChunk callback is provided for real-time progress.
  * Retries up to 3 times on transient failures (429, 5xx, network errors).
  */
-export declare function callLLM(prompt: string, config: LLMConfig, systemPrompt?: string, options?: CallLLMOptions): Promise<LLMResponse>;
+export declare function callLLM(prompt: LLMUserContent, config: LLMConfig, systemPrompt?: string, options?: CallLLMOptions): Promise<LLMResponse>;

package/dist/core/wiki/llm-client.js

@@ -1,5 +1,18 @@
 import { logger } from '../logger.js';
 import { CircuitOpenError, ResilientFetchExhaustedError, resilientFetch } from '../../_shared/index.js';
+export const MINIMAX_OPENAI_BASE_URLS = {
+    global_en: 'https://api.minimax.io/v1',
+    cn_zh: 'https://api.minimaxi.com/v1',
+};
+export const MINIMAX_MODEL_IDS = ['MiniMax-M3', 'MiniMax-M2.7'];
+export function resolveMiniMaxThinkingMode(model, reasoningOverride) {
+    if (model === MINIMAX_MODEL_IDS[1])
+        return 'always_on';
+    if (model === MINIMAX_MODEL_IDS[0]) {
+        return reasoningOverride === false ? 'disabled' : 'adaptive';
+    }
+    return undefined;
+}
 /**
  * Resolve LLM configuration from env vars, saved config, and optional overrides.
  * Priority: overrides (CLI flags) > env vars > ~/.gitnexus/config.json > error
@@ -9,7 +22,9 @@ import { CircuitOpenError, ResilientFetchExhaustedError, resilientFetch } from '
 export async function resolveLLMConfig(overrides) {
     const { loadCLIConfig } = await import('../../storage/repo-manager.js');
     const savedConfig = await loadCLIConfig();
-    const savedProvider = overrides?.provider ?? savedConfig.provider;
+    const hasLegacyHttpConfig = !savedConfig.provider && !!(savedConfig.model || savedConfig.baseUrl);
+    const savedProvider = overrides?.provider ?? savedConfig.provider ?? (hasLegacyHttpConfig ? 'openai' : 'minimax');
+    const reuseSavedHttpConfig = savedConfig.provider === savedProvider || (hasLegacyHttpConfig && savedProvider === 'openai');
     const savedLocalModel = savedProvider === 'cursor'
         ? savedConfig.cursorModel
         : savedProvider === 'claude'
@@ -24,25 +39,34 @@ export async function resolveLLMConfig(overrides) {
         savedProvider === 'codex' ||
         savedProvider === 'opencode';
     const apiKey = overrides?.apiKey ||
-        process.env.GITNEXUS_API_KEY ||
-        process.env.OPENAI_API_KEY ||
-        savedConfig.apiKey ||
+        (savedProvider === 'minimax' ? process.env.MINIMAX_API_KEY : undefined) ||
+        (savedProvider !== 'minimax' ? process.env.GITNEXUS_API_KEY : undefined) ||
+        (savedProvider !== 'minimax' ? process.env.OPENAI_API_KEY : undefined) ||
+        (reuseSavedHttpConfig ? savedConfig.apiKey : undefined) ||
         '';
     return {
         apiKey,
         baseUrl: overrides?.baseUrl ||
             process.env.GITNEXUS_LLM_BASE_URL ||
-            savedConfig.baseUrl ||
-            'https://openrouter.ai/api/v1',
+            (reuseSavedHttpConfig ? savedConfig.baseUrl : undefined) ||
+            (savedProvider === 'minimax'
+                ? MINIMAX_OPENAI_BASE_URLS.global_en
+                : 'https://openrouter.ai/api/v1'),
         model: overrides?.model ||
             (localProvider ? undefined : process.env.GITNEXUS_MODEL) ||
             savedLocalModel ||
-            (localProvider ? '' : savedConfig.model || 'minimax/minimax-m2.5'),
+            (localProvider
+                ? ''
+                : (reuseSavedHttpConfig ? savedConfig.model : undefined) ||
+                    (savedProvider === 'minimax' ? MINIMAX_MODEL_IDS[0] : '')),
         maxTokens: overrides?.maxTokens ?? 16_384,
         temperature: overrides?.temperature ?? 0,
-        provider: savedProvider ?? 'openai',
-        apiVersion: overrides?.apiVersion || process.env.GITNEXUS_AZURE_API_VERSION || savedConfig.apiVersion,
-        isReasoningModel: overrides?.isReasoningModel ?? savedConfig.isReasoningModel,
+        provider: savedProvider,
+        apiVersion: overrides?.apiVersion ||
+            (savedProvider === 'azure' ? process.env.GITNEXUS_AZURE_API_VERSION : undefined) ||
+            (reuseSavedHttpConfig ? savedConfig.apiVersion : undefined),
+        isReasoningModel: overrides?.isReasoningModel ??
+            (reuseSavedHttpConfig ? savedConfig.isReasoningModel : undefined),
         allowedInsecureHttpHosts: overrides?.allowedInsecureHttpHosts ??
             parseLLMAllowedInsecureHttpHosts(process.env[LLM_ALLOW_INSECURE_CONNECTION_ENV]),
     };
@@ -193,8 +217,13 @@ export async function callLLM(prompt, config, systemPrompt, options) {
     if (azure && !config.apiVersion && config.baseUrl.includes('/deployments/')) {
         logger.warn('[gitnexus] Warning: Azure legacy deployment URL detected but no api-version set. Add --api-version 2024-10-21 or use the v1 API format.');
     }
-    // Detect reasoning model (o1, o3, o4-mini etc.) or explicit override
-    const reasoning = isReasoningModel(config.model, config.isReasoningModel);
+    const miniMaxThinkingMode = config.provider === 'minimax'
+        ? resolveMiniMaxThinkingMode(config.model, config.isReasoningModel)
+        : undefined;
+    // Detect reasoning models or explicit provider-specific thinking configuration.
+    const reasoning = miniMaxThinkingMode
+        ? miniMaxThinkingMode !== 'disabled'
+        : isReasoningModel(config.model, config.isReasoningModel);
     const url = buildRequestUrl(config.baseUrl, azure ? config.apiVersion : undefined);
     const useStream = !!options?.onChunk;
     // Build request body — reasoning models reject temperature and use max_completion_tokens
@@ -202,6 +231,12 @@ export async function callLLM(prompt, config, systemPrompt, options) {
         model: config.model,
         messages,
     };
+    if (miniMaxThinkingMode === 'adaptive' || miniMaxThinkingMode === 'disabled') {
+        body.thinking = { type: miniMaxThinkingMode };
+    }
+    if (config.provider === 'minimax') {
+        body.reasoning_split = true;
+    }
     // max_tokens is deprecated; use max_completion_tokens for all models
     body.max_completion_tokens = config.maxTokens;
     // Only send temperature for non-Azure providers — some Azure models reject non-default values

package/dist/core/wiki/prompts.d.ts

@@ -30,6 +30,25 @@ export declare function formatFileListForGrouping(files: Array<{
  * Build a directory tree string from file paths.
  */
 export declare function formatDirectoryTree(filePaths: string[]): string;
+/**
+ * Call edges kept on a page. Declared here because this is where the
+ * requirement is: a limit exists at all only because `formatCallEdges` renders
+ * these lists into a prompt, and every such list reaches the LLM through it.
+ *
+ * The call-edge queries in `graph-queries.ts` import this value for their
+ * Cypher `LIMIT`s rather than restate it. That is the same cut moved earlier —
+ * fetching rows the slice below would discard is pure waste, and at module
+ * scale it is most of the query (#2787) — so fetch and display must agree, and
+ * a second number could only ever drift from this one.
+ *
+ * The import runs that way and not the other because this module has no
+ * imports of its own. `graph-queries.ts` may read this; sending it back the
+ * other way would give a pure template module a transitive dependency on the
+ * LadybugDB pool adapter, and would make the cap vanish under the tests that
+ * `vi.mock` `graph-queries.js` — a mock factory omitting the constant leaves
+ * `slice(0, undefined)`, which keeps every edge.
+ */
+export declare const CALL_EDGE_LIMIT = 30;
 /**
  * Format call edges as readable text.
  */

package/dist/core/wiki/prompts.js

@@ -146,6 +146,25 @@ export function formatDirectoryTree(filePaths) {
     return (sorted.slice(0, 50).join('\n') +
         (sorted.length > 50 ? `\n... and ${sorted.length - 50} more directories` : ''));
 }
+/**
+ * Call edges kept on a page. Declared here because this is where the
+ * requirement is: a limit exists at all only because `formatCallEdges` renders
+ * these lists into a prompt, and every such list reaches the LLM through it.
+ *
+ * The call-edge queries in `graph-queries.ts` import this value for their
+ * Cypher `LIMIT`s rather than restate it. That is the same cut moved earlier —
+ * fetching rows the slice below would discard is pure waste, and at module
+ * scale it is most of the query (#2787) — so fetch and display must agree, and
+ * a second number could only ever drift from this one.
+ *
+ * The import runs that way and not the other because this module has no
+ * imports of its own. `graph-queries.ts` may read this; sending it back the
+ * other way would give a pure template module a transitive dependency on the
+ * LadybugDB pool adapter, and would make the cap vanish under the tests that
+ * `vi.mock` `graph-queries.js` — a mock factory omitting the constant leaves
+ * `slice(0, undefined)`, which keeps every edge.
+ */
+export const CALL_EDGE_LIMIT = 30;
 /**
  * Format call edges as readable text.
  */
@@ -153,7 +172,7 @@ export function formatCallEdges(edges) {
     if (edges.length === 0)
         return 'None';
     return edges
-        .slice(0, 30)
+        .slice(0, CALL_EDGE_LIMIT)
         .map((e) => `${e.fromName} (${shortPath(e.fromFile)}) → ${e.toName} (${shortPath(e.toFile)})`)
         .join('\n');
 }