gitnexus 1.6.10-rc.4 → 1.6.10-rc.5

package/dist/core/group/extractors/manifest-extractor.js

@@ -7,6 +7,10 @@ import { logger } from '../../logger.js';
 // reserved-keyword labels `Macro` and `Union`, and LadybugDB's parser rejects
 // a disjunction that names a reserved keyword (#2325) — which the resolver's
 // try/catch then swallowed. `labels(n) IN` has no such collision.
+// This list overlaps `ingestion/utils/symbol-labels.ts` (SYMBOL_NODE_LABELS) but
+// is a deliberate SUBSET — it omits `Namespace`/`Variable`/`Module`. Unifying the
+// two would widen which nodes resolve as contract symbols and must update the
+// #2325 test, so they are intentionally kept separate for now.
 export const CUSTOM_CONTRACT_RESOLVE_QUERY = `MATCH (n)
    WHERE labels(n) IN ['Function','Method','Class','Interface','Struct','Enum','Trait','Constructor','TypeAlias','Impl','Macro','Union','Typedef','Property','Record','Delegate','Annotation','Template','Const','Static','CodeElement']
      AND n.name = $symbolName

package/dist/core/ingestion/cobol/jcl-processor.js

@@ -17,6 +17,7 @@
  */
 import { parseJcl } from './jcl-parser.js';
 import { generateId } from '../../../lib/utils.js';
+import { toZeroBasedLine } from '../utils/line-base.js';
 /**
  * Process JCL files and integrate into the knowledge graph.
  *
@@ -71,8 +72,8 @@ function integrateJclResults(graph, parsed, filePath, moduleNames) {
             properties: {
                 name: job.name,
                 filePath,
-                startLine: job.line,
-                endLine: job.line,
+                startLine: toZeroBasedLine(job.line),
+                endLine: toZeroBasedLine(job.line),
                 description: `jcl-job${classPart}${msgPart}`,
             },
         });
@@ -105,8 +106,8 @@ function integrateJclResults(graph, parsed, filePath, moduleNames) {
             properties: {
                 name: step.name,
                 filePath,
-                startLine: step.line,
-                endLine: step.line,
+                startLine: toZeroBasedLine(step.line),
+                endLine: toZeroBasedLine(step.line),
                 description: `jcl-step${pgmPart}${procPart}`,
             },
         });
@@ -170,8 +171,8 @@ function integrateJclResults(graph, parsed, filePath, moduleNames) {
                 properties: {
                     name: dd.dataset,
                     filePath,
-                    startLine: dd.line,
-                    endLine: dd.line,
+                    startLine: toZeroBasedLine(dd.line),
+                    endLine: toZeroBasedLine(dd.line),
                     description: `jcl-dataset${dispPart}`,
                 },
             });
@@ -202,8 +203,8 @@ function integrateJclResults(graph, parsed, filePath, moduleNames) {
             properties: {
                 name: proc.name,
                 filePath,
-                startLine: proc.line,
-                endLine: proc.line,
+                startLine: toZeroBasedLine(proc.line),
+                endLine: toZeroBasedLine(proc.line),
                 description: 'jcl-proc-instream',
             },
         });

package/dist/core/ingestion/cobol-processor.js

@@ -14,6 +14,7 @@
  */
 import path from 'node:path';
 import { generateId } from '../../lib/utils.js';
+import { toZeroBasedLine } from './utils/line-base.js';
 import { SupportedLanguages } from '../../_shared/index.js';
 import { preprocessCobolSource, extractCobolSymbolsWithRegex, } from './cobol/cobol-preprocessor.js';
 import { expandCopies } from './cobol/cobol-copy-expander.js';
@@ -275,8 +276,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: extracted.programName,
                 filePath,
-                startLine: 1,
-                endLine: lines.length,
+                startLine: toZeroBasedLine(1),
+                endLine: toZeroBasedLine(lines.length),
                 language: SupportedLanguages.Cobol,
                 isExported: true,
                 description: metaDesc || undefined,
@@ -310,8 +311,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: prog.name,
                 filePath,
-                startLine: prog.startLine,
-                endLine: prog.endLine,
+                startLine: toZeroBasedLine(prog.startLine),
+                endLine: toZeroBasedLine(prog.endLine),
                 language: SupportedLanguages.Cobol,
                 isExported: true,
                 description: `nested-program${prog.isCommon ? ' common' : ''}`,
@@ -349,8 +350,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: sec.name,
                 filePath,
-                startLine: sec.line,
-                endLine: nextLine,
+                startLine: toZeroBasedLine(sec.line),
+                endLine: toZeroBasedLine(nextLine),
                 language: SupportedLanguages.Cobol,
                 isExported: true,
             },
@@ -379,8 +380,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: para.name,
                 filePath,
-                startLine: para.line,
-                endLine: nextLine,
+                startLine: toZeroBasedLine(para.line),
+                endLine: toZeroBasedLine(nextLine),
                 language: SupportedLanguages.Cobol,
                 isExported: true,
             },
@@ -412,8 +413,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: item.name,
                 filePath,
-                startLine: item.line,
-                endLine: item.line,
+                startLine: toZeroBasedLine(item.line),
+                endLine: toZeroBasedLine(item.line),
                 language: SupportedLanguages.Cobol,
                 description: `level:${item.level} section:${item.section}${item.pic ? ` pic:${item.pic}` : ''}`,
             },
@@ -506,8 +507,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
                 properties: {
                     name: `CALL ${call.target}`,
                     filePath,
-                    startLine: call.line,
-                    endLine: call.line,
+                    startLine: toZeroBasedLine(call.line),
+                    endLine: toZeroBasedLine(call.line),
                     language: SupportedLanguages.Cobol,
                     description: 'dynamic-call (target is a data item, not resolvable statically)',
                 },
@@ -619,8 +620,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: `EXEC SQL ${sql.operation}`,
                 filePath,
-                startLine: sql.line,
-                endLine: sql.line,
+                startLine: toZeroBasedLine(sql.line),
+                endLine: toZeroBasedLine(sql.line),
                 language: SupportedLanguages.Cobol,
                 description: `tables:[${sql.tables.join(',')}] cursors:[${sql.cursors.join(',')}]`,
             },
@@ -691,8 +692,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: `EXEC CICS ${cics.command}`,
                 filePath,
-                startLine: cics.line,
-                endLine: cics.line,
+                startLine: toZeroBasedLine(cics.line),
+                endLine: toZeroBasedLine(cics.line),
                 language: SupportedLanguages.Cobol,
                 description: [
                     cics.mapName && `map:${cics.mapName}`,
@@ -726,8 +727,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
                     properties: {
                         name: `CICS ${cics.command} ${cics.programName}`,
                         filePath,
-                        startLine: cics.line,
-                        endLine: cics.line,
+                        startLine: toZeroBasedLine(cics.line),
+                        endLine: toZeroBasedLine(cics.line),
                         language: SupportedLanguages.Cobol,
                         description: `cics-dynamic-program (target is data item ${cics.programName})`,
                     },
@@ -879,8 +880,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: entry.name,
                 filePath,
-                startLine: entry.line,
-                endLine: entry.line,
+                startLine: toZeroBasedLine(entry.line),
+                endLine: toZeroBasedLine(entry.line),
                 language: SupportedLanguages.Cobol,
                 isExported: true,
                 description: entry.parameters.length > 0 ? `using:${entry.parameters.join(',')}` : undefined,
@@ -1014,8 +1015,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: `EXEC DLI ${dli.verb}`,
                 filePath,
-                startLine: dli.line,
-                endLine: dli.line,
+                startLine: toZeroBasedLine(dli.line),
+                endLine: toZeroBasedLine(dli.line),
                 language: SupportedLanguages.Cobol,
                 description: [
                     dli.segmentName && `segment:${dli.segmentName}`,
@@ -1148,8 +1149,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: fd.selectName,
                 filePath,
-                startLine: fd.line,
-                endLine: fd.line,
+                startLine: toZeroBasedLine(fd.line),
+                endLine: toZeroBasedLine(fd.line),
                 language: SupportedLanguages.Cobol,
                 description: `assign:${fd.assignTo}${fd.isOptional ? ' optional' : ''}${fd.organization ? ` org:${fd.organization}` : ''}${fd.access ? ` access:${fd.access}` : ''}`,
             },
@@ -1231,8 +1232,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
                 properties: {
                     name: `CANCEL ${cancel.target}`,
                     filePath,
-                    startLine: cancel.line,
-                    endLine: cancel.line,
+                    startLine: toZeroBasedLine(cancel.line),
+                    endLine: toZeroBasedLine(cancel.line),
                     language: SupportedLanguages.Cobol,
                     description: 'dynamic-cancel (target is a data item, not resolvable statically)',
                 },

package/dist/core/ingestion/emit-references.js

@@ -44,6 +44,7 @@
  * ancestor scope, and if THAT produces nothing either the edge is
  * skipped (with a count returned in `EmitStats.skippedNoCaller`).
  */
+import { toZeroBasedLine } from './utils/line-base.js';
 /**
  * Drain `referenceIndex.bySourceScope` into graph edges.
  *
@@ -95,8 +96,8 @@ export function emitScopeGraph(input) {
             properties: {
                 name: scope.kind,
                 filePath: scope.filePath,
-                startLine: scope.range.startLine,
-                endLine: scope.range.endLine,
+                startLine: toZeroBasedLine(scope.range.startLine),
+                endLine: toZeroBasedLine(scope.range.endLine),
                 description: `Scope: ${scope.kind}`,
             },
         });

package/dist/core/ingestion/markdown-processor.js

@@ -7,6 +7,7 @@
  */
 import path from 'node:path';
 import { generateId } from '../../lib/utils.js';
+import { toZeroBasedLine } from './utils/line-base.js';
 const HEADING_RE = /^(#{1,6})\s+(.+)$/;
 const LINK_RE = /\[([^\]]*)\]\(([^)]+)\)/g;
 const MD_EXTENSIONS = new Set(['.md', '.mdx']);
@@ -59,8 +60,8 @@ export const processMarkdown = (graph, files, allPathSet) => {
                 properties: {
                     name: heading,
                     filePath: file.path,
-                    startLine: lineNum,
-                    endLine,
+                    startLine: toZeroBasedLine(lineNum),
+                    endLine: toZeroBasedLine(endLine),
                     level,
                     description: `h${level}`,
                 },

package/dist/core/ingestion/utils/line-base.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Convert a 1-based source line number to the 0-based convention used by
+ * GraphNode `startLine`/`endLine`.
+ *
+ * The graph layer stores line numbers 0-based (tree-sitter `startPosition.row`),
+ * and this is load-bearing: the taint/PDG/CFG join and the MCP consumers all add
+ * `+ 1` to recover 1-based (see `summary-harvest-driver.ts` — "Function/Method
+ * node startLine is 0-based"). Most emitters get 0-based for free from
+ * tree-sitter. The exceptions are the regex-based COBOL/JCL processors (their
+ * parsers use `lineNum = i + 1`) and the scope-capture path (`Capture` ranges
+ * are 1-based per RFC §2.1). Those must convert to 0-based when they build a
+ * graph node, or the exact-content slice in `csv-generator.ts` drops the
+ * symbol's declaration line (#2379) and reported line numbers are off (#2377).
+ *
+ * Apply this ONLY at the graph-node `startLine:`/`endLine:` assignment. The
+ * parser-internal 1-based values (`.line`, `prog.startLine`) stay 1-based —
+ * they feed `L${line}` node/edge IDs and line-range containment checks that
+ * must not shift. The clamp guards degenerate inputs (line 0 / empty files).
+ */
+export declare const toZeroBasedLine: (oneBasedLine: number) => number;

package/dist/core/ingestion/utils/line-base.js

@@ -0,0 +1,20 @@
+/**
+ * Convert a 1-based source line number to the 0-based convention used by
+ * GraphNode `startLine`/`endLine`.
+ *
+ * The graph layer stores line numbers 0-based (tree-sitter `startPosition.row`),
+ * and this is load-bearing: the taint/PDG/CFG join and the MCP consumers all add
+ * `+ 1` to recover 1-based (see `summary-harvest-driver.ts` — "Function/Method
+ * node startLine is 0-based"). Most emitters get 0-based for free from
+ * tree-sitter. The exceptions are the regex-based COBOL/JCL processors (their
+ * parsers use `lineNum = i + 1`) and the scope-capture path (`Capture` ranges
+ * are 1-based per RFC §2.1). Those must convert to 0-based when they build a
+ * graph node, or the exact-content slice in `csv-generator.ts` drops the
+ * symbol's declaration line (#2379) and reported line numbers are off (#2377).
+ *
+ * Apply this ONLY at the graph-node `startLine:`/`endLine:` assignment. The
+ * parser-internal 1-based values (`.line`, `prog.startLine`) stay 1-based —
+ * they feed `L${line}` node/edge IDs and line-range containment checks that
+ * must not shift. The clamp guards degenerate inputs (line 0 / empty files).
+ */
+export const toZeroBasedLine = (oneBasedLine) => Math.max(0, oneBasedLine - 1);

package/dist/core/ingestion/utils/symbol-labels.d.ts

@@ -0,0 +1,21 @@
+import type { NodeLabel } from '../../../_shared/index.js';
+/**
+ * Graph-node labels that represent a resolvable code symbol — a definition with
+ * its own source span (function, type, member, module-like container).
+ *
+ * These get EXACT source-span content in the FTS index: `csv-generator.ts`
+ * slices exactly `[startLine, endLine]` for them (no ±2 padding), while every
+ * other label keeps the context window. That exactness depends on the 0-based
+ * `startLine`/`endLine` invariant enforced by `line-base.ts` — the slice is only
+ * correct because all emitters store 0-based lines. Keep the two together.
+ *
+ * Single source of truth so the set can't silently drift the way the inline copy
+ * did in #2379.
+ *
+ * NOTE: `group/extractors/manifest-extractor.ts`'s `CUSTOM_CONTRACT_RESOLVE_QUERY`
+ * carries a near-identical hand-list that is intentionally a SUBSET — it excludes
+ * `Namespace`, `Variable`, `Module`. Unifying the two needs a contract-resolution
+ * behavior check (would widen which nodes resolve as contract symbols), so it is
+ * deliberately left separate for now.
+ */
+export declare const SYMBOL_NODE_LABELS: ReadonlySet<NodeLabel>;

package/dist/core/ingestion/utils/symbol-labels.js

@@ -0,0 +1,45 @@
+/**
+ * Graph-node labels that represent a resolvable code symbol — a definition with
+ * its own source span (function, type, member, module-like container).
+ *
+ * These get EXACT source-span content in the FTS index: `csv-generator.ts`
+ * slices exactly `[startLine, endLine]` for them (no ±2 padding), while every
+ * other label keeps the context window. That exactness depends on the 0-based
+ * `startLine`/`endLine` invariant enforced by `line-base.ts` — the slice is only
+ * correct because all emitters store 0-based lines. Keep the two together.
+ *
+ * Single source of truth so the set can't silently drift the way the inline copy
+ * did in #2379.
+ *
+ * NOTE: `group/extractors/manifest-extractor.ts`'s `CUSTOM_CONTRACT_RESOLVE_QUERY`
+ * carries a near-identical hand-list that is intentionally a SUBSET — it excludes
+ * `Namespace`, `Variable`, `Module`. Unifying the two needs a contract-resolution
+ * behavior check (would widen which nodes resolve as contract symbols), so it is
+ * deliberately left separate for now.
+ */
+export const SYMBOL_NODE_LABELS = new Set([
+    'Function',
+    'Method',
+    'Class',
+    'Interface',
+    'CodeElement',
+    'Struct',
+    'Enum',
+    'Macro',
+    'Typedef',
+    'Union',
+    'Namespace',
+    'Trait',
+    'Impl',
+    'TypeAlias',
+    'Const',
+    'Static',
+    'Variable',
+    'Property',
+    'Record',
+    'Delegate',
+    'Annotation',
+    'Constructor',
+    'Template',
+    'Module',
+]);

package/dist/core/lbug/csv-generator.js

@@ -17,6 +17,7 @@ import path from 'path';
 import { NODE_TABLES } from './schema.js';
 import { RelPairRouter } from './rel-pair-routing.js';
 import { parseTruthyEnv } from '../ingestion/utils/env.js';
+import { SYMBOL_NODE_LABELS } from '../ingestion/utils/symbol-labels.js';
 import { applyCjkSegmentationIfEnabled } from '../search/cjk-segmentation.js';
 /**
  * Deterministic output ordering — optional (out-of-core / windowed-resolve
@@ -187,6 +188,10 @@ class FileContentCache {
 export const normalizeFtsText = (text) => text.replace(/[\r\n\t]+/g, ' ');
 /** Composes both FTS-text transforms for the `description` column — one place for the six emission sites below to call, instead of repeating the composition. */
 const formatFtsDescription = (description) => normalizeFtsText(applyCjkSegmentationIfEnabled(description));
+// Labels that get exact source-span content (no ±2 window). Single source of
+// truth in `symbol-labels.ts` — see there for why the exactness depends on the
+// 0-based line invariant. Kept as a named alias to read intent at the use site.
+const EXACT_SYMBOL_CONTENT_LABELS = SYMBOL_NODE_LABELS;
 const extractContent = async (node, contentCache) => {
     const filePath = node.properties.filePath;
     const content = await contentCache.get(filePath);
@@ -209,8 +214,9 @@ const extractContent = async (node, contentCache) => {
     if (startLine === undefined || endLine === undefined)
         return '';
     const lines = content.split('\n');
-    const start = Math.max(0, startLine - 2);
-    const end = Math.min(lines.length - 1, endLine + 2);
+    const exactSymbolContent = EXACT_SYMBOL_CONTENT_LABELS.has(node.label);
+    const start = Math.max(0, exactSymbolContent ? startLine : startLine - 2);
+    const end = Math.min(lines.length - 1, exactSymbolContent ? endLine : endLine + 2);
     const snippet = lines.slice(start, end + 1).join('\n');
     const MAX_SNIPPET = 5000;
     const capped = snippet.length > MAX_SNIPPET ? snippet.slice(0, MAX_SNIPPET) + '\n... [truncated]' : snippet;

package/dist/mcp/local/line-display.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Convert a 0-based GraphNode `startLine`/`endLine` to the 1-based line number
+ * shown to humans and LLMs in MCP tool output.
+ *
+ * Storage is 0-based (tree-sitter `startPosition.row`; see
+ * `ingestion/utils/line-base.ts`), which matches editors/`sed`/`less -N` only
+ * after `+ 1`. The `context`, `query`, and `impact` tools present line numbers a
+ * user cross-references against source, so they convert here at the response
+ * boundary (#2377).
+ *
+ * Apply ONLY to a symbol node's 0-based `startLine`/`endLine`. Do NOT apply to:
+ *   - BasicBlock / CFG `functionStartLine` and PDG statement lines — already
+ *     1-based (they use `startPosition.row + 1`);
+ *   - the internal `sym.startLine + 1` join params that target the 1-based
+ *     BasicBlock id space;
+ *   - raw `cypher` results, which pass LadybugDB columns through verbatim and
+ *     stay 0-based (documented).
+ *
+ * `undefined`/`null` pass through so optional line fields stay absent.
+ */
+export declare function toDisplayLine(zeroBasedLine: number): number;
+export declare function toDisplayLine(zeroBasedLine: number | null | undefined): number | undefined;

package/dist/mcp/local/line-display.js

@@ -0,0 +1,3 @@
+export function toDisplayLine(zeroBasedLine) {
+    return typeof zeroBasedLine === 'number' ? zeroBasedLine + 1 : undefined;
+}

package/dist/mcp/local/local-backend.d.ts

@@ -172,6 +172,14 @@ export declare class LocalBackend {
      * Cross-repo group tools (CLI). Shares logic with MCP `group_*` handlers.
      */
     getGroupService(): GroupService;
+    /**
+     * Adapt local `trace` to the group port. The assembled group/cross-repo trace
+     * presents 1-based endpoints (via resolveSymbolForGroup), so convert the hop
+     * lines here too — otherwise one response mixes 1-based endpoints with 0-based
+     * hops (#2380). Single-repo `trace` dispatches directly (not through this
+     * port) and stays 0-based (documented full-parity follow-up).
+     */
+    private traceForGroup;
     /**
      * Adapt the shared symbol resolver to the GroupToolPort contract. Used by the
      * cross-repo trace path to locate which member repo an endpoint lives in and

package/dist/mcp/local/local-backend.js

@@ -10,6 +10,7 @@ import path from 'path';
 import { createHash } from 'crypto';
 import { initLbug, executeQuery, executeParameterized, closeLbug, isLbugReady, } from '../../core/lbug/pool-adapter.js';
 import { isValidQueryParams } from '../../core/lbug/query-params.js';
+import { toDisplayLine } from './line-display.js';
 import { isWalCorruptionError, WAL_RECOVERY_SUGGESTION } from '../../core/lbug/lbug-config.js';
 // Embedding imports are lazy (dynamic import) to avoid loading onnxruntime-node
 // at MCP server startup — crashes on unsupported Node ABI versions (#89)
@@ -453,7 +454,7 @@ export class LocalBackend {
                 query: (r, p) => this.query(r, p),
                 impactByUid: (id, uid, d, o) => this.impactByUid(id, uid, d, o),
                 context: (r, p) => this.context(r, p),
-                trace: (r, p) => this.trace(r, p),
+                trace: (r, p) => this.traceForGroup(r, p),
                 resolveSymbol: (r, q) => this.resolveSymbolForGroup(r, q),
                 pdgFlows: (r, anchor, opts) => this.pdgFlowsForGroup(r, anchor, opts),
             };
@@ -461,6 +462,23 @@ export class LocalBackend {
         }
         return this.groupToolSvc;
     }
+    /**
+     * Adapt local `trace` to the group port. The assembled group/cross-repo trace
+     * presents 1-based endpoints (via resolveSymbolForGroup), so convert the hop
+     * lines here too — otherwise one response mixes 1-based endpoints with 0-based
+     * hops (#2380). Single-repo `trace` dispatches directly (not through this
+     * port) and stays 0-based (documented full-parity follow-up).
+     */
+    async traceForGroup(repo, params) {
+        const result = await this.trace(repo, params);
+        const hops = result.hops;
+        if (Array.isArray(hops)) {
+            for (const hop of hops) {
+                hop.startLine = toDisplayLine(hop.startLine);
+            }
+        }
+        return result;
+    }
     /**
      * Adapt the shared symbol resolver to the GroupToolPort contract. Used by the
      * cross-repo trace path to locate which member repo an endpoint lives in and
@@ -478,8 +496,8 @@ export class LocalBackend {
                     name: s.name,
                     type: s.type,
                     filePath: s.filePath,
-                    startLine: s.startLine,
-                    endLine: s.endLine,
+                    startLine: toDisplayLine(s.startLine),
+                    endLine: toDisplayLine(s.endLine),
                 },
             };
         }
@@ -491,7 +509,7 @@ export class LocalBackend {
                     name: c.name,
                     type: c.type,
                     filePath: c.filePath,
-                    startLine: c.startLine,
+                    startLine: toDisplayLine(c.startLine),
                 })),
             };
         }
@@ -1572,8 +1590,8 @@ export class LocalBackend {
                 name: sym.name,
                 type: sym.type,
                 filePath: sym.filePath,
-                startLine: sym.startLine,
-                endLine: sym.endLine,
+                startLine: toDisplayLine(sym.startLine),
+                endLine: toDisplayLine(sym.endLine),
                 ...(module ? { module } : {}),
                 ...(includeContent && content ? { content } : {}),
             };
@@ -1799,8 +1817,11 @@ export class LocalBackend {
                             name: sym.name || sym[1],
                             type: sym.type || sym[2],
                             filePath: sym.filePath || sym[3],
-                            startLine: sym.startLine || sym[4],
-                            endLine: sym.endLine || sym[5],
+                            // Raw 0-based here — `bm25Search` is only called from `query()`,
+                            // whose aggregation loop applies `toDisplayLine` once (see below).
+                            // Converting here too would double-shift BM25-matched lines (#2380).
+                            startLine: sym.startLine ?? sym[4],
+                            endLine: sym.endLine ?? sym[5],
                             bm25Score: bm25Result.score,
                         });
                     }
@@ -2396,7 +2417,7 @@ export class LocalBackend {
                     name: c.name,
                     kind: c.type,
                     filePath: c.filePath,
-                    line: c.startLine,
+                    line: toDisplayLine(c.startLine),
                     score: Number(c.score.toFixed(2)),
                 })),
             };
@@ -2603,8 +2624,8 @@ export class LocalBackend {
                 name: sym.name || sym[1],
                 kind: symKind,
                 filePath: sym.filePath || sym[3],
-                startLine: sym.startLine || sym[4],
-                endLine: sym.endLine || sym[5],
+                startLine: toDisplayLine(sym.startLine ?? sym[4]),
+                endLine: toDisplayLine(sym.endLine ?? sym[5]),
                 ...(include_content && (sym.content || sym[6]) ? { content: sym.content || sym[6] } : {}),
                 ...(methodMetadata ? { methodMetadata } : {}),
             },
@@ -2680,7 +2701,7 @@ export class LocalBackend {
                         name: c.name,
                         kind: c.type,
                         filePath: c.filePath,
-                        line: c.startLine,
+                        line: toDisplayLine(c.startLine),
                         score: Number(c.score.toFixed(2)),
                     })),
                 },
@@ -2698,11 +2719,14 @@ export class LocalBackend {
             return {
                 anchorClause: 'a.id STARTS WITH $idPrefix AND a.startLine >= $symStart AND a.startLine <= $symEnd',
                 queryParams: { idPrefix, symStart: sym.startLine + 1, symEnd: sym.endLine + 1 },
+                // Display anchor is 1-based, matching the ambiguous-candidate branch and
+                // the context/query/impact tools (#2380). This is display-only — the
+                // BasicBlock join above uses the raw `sym.startLine + 1` in `symStart`.
                 anchor: {
                     file: sym.filePath,
                     symbol: sym.name,
-                    startLine: sym.startLine,
-                    endLine: sym.endLine,
+                    startLine: toDisplayLine(sym.startLine),
+                    endLine: toDisplayLine(sym.endLine),
                 },
             };
         }
@@ -4036,7 +4060,7 @@ export class LocalBackend {
                         name: c.name,
                         kind: c.type,
                         filePath: c.filePath,
-                        line: c.startLine,
+                        line: toDisplayLine(c.startLine),
                         score: Number(c.score.toFixed(2)),
                     })),
                 };
@@ -4089,7 +4113,7 @@ export class LocalBackend {
                     name: c.name,
                     kind: c.type,
                     filePath: c.filePath,
-                    line: c.startLine,
+                    line: toDisplayLine(c.startLine),
                     score: Number(c.score.toFixed(2)),
                     impactedCount: summary?.impactedCount ?? 0,
                     risk: summary?.risk ?? 'UNKNOWN',

package/dist/mcp/local/pdg-impact.d.ts

@@ -34,8 +34,10 @@ export declare function splitCalleeIds(raw: unknown): string[];
  * Contract version of the mode:'pdg' impact result shape. A stable discriminator
  * for external MCP/agent consumers — distinct from the DB INCREMENTAL_SCHEMA_VERSION.
  * Bump on any breaking change to the PDG result fields.
+ * v2: `startLine` in the result is now 1-based display (#2380), matching the
+ * context/query/impact tools (was 0-based).
  */
-export declare const PDG_RESULT_VERSION: 1;
+export declare const PDG_RESULT_VERSION: 2;
 /** A reachable dependence block resolved to its source statement. */
 export interface PdgStatement {
     /** 1-based source line where the statement's block starts. */
@@ -105,7 +107,7 @@ export interface PdgInterproceduralImpact {
 export interface PdgImpactBaseResult extends PdgImpactParityFields {
     mode: 'pdg';
     /** Contract version of the mode:'pdg' impact result shape; bump on any breaking change to the PDG result fields. */
-    pdgResultVersion: 1;
+    pdgResultVersion: 2;
     target: PdgImpactTarget;
     direction: 'upstream' | 'downstream';
     impactedCount: number;
@@ -172,7 +174,7 @@ export interface PdgImpactDegradedResult extends PdgImpactBaseResult {
 export interface PdgImpactErrorResult {
     mode?: 'pdg';
     /** Contract version of the mode:'pdg' impact result shape; bump on any breaking change to the PDG result fields. */
-    pdgResultVersion: 1;
+    pdgResultVersion: 2;
     error: string;
     target: PdgImpactTarget;
     direction: 'upstream' | 'downstream';

package/dist/mcp/local/pdg-impact.js

@@ -9,6 +9,7 @@ import path from 'path';
 import { loadMeta } from '../../storage/repo-manager.js';
 import { IMPACT_MAX_DEPTH, PDG_QUERY_DEFAULT_LIMIT, PDG_QUERY_MAX_LIMIT } from '../tools.js';
 import { CALLEES_TRUNCATED_SENTINEL, CALLEE_ID_SEP } from '../../core/ingestion/cfg/emit.js';
+import { toDisplayLine } from './line-display.js';
 import { decodeCallSummary } from '../../core/ingestion/taint/call-summary-codec.js';
 import { decodeReachingDefReason } from '../../core/ingestion/cfg/reaching-def-reason-codec.js';
 import { getProviderForFile } from '../../core/ingestion/languages/index.js';
@@ -84,8 +85,10 @@ export function splitCalleeIds(raw) {
  * Contract version of the mode:'pdg' impact result shape. A stable discriminator
  * for external MCP/agent consumers — distinct from the DB INCREMENTAL_SCHEMA_VERSION.
  * Bump on any breaking change to the PDG result fields.
+ * v2: `startLine` in the result is now 1-based display (#2380), matching the
+ * context/query/impact tools (was 0-based).
  */
-export const PDG_RESULT_VERSION = 1;
+export const PDG_RESULT_VERSION = 2;
 /**
  * FU-B-2 intra-block def→use line walk. Given a block's self REACHING_DEF
  * def→use line PAIRS (every `defLine → useLine` step decoded from the edge
@@ -519,7 +522,7 @@ function assemblePdgImpactResult(input) {
         name: s.name,
         type: s.type,
         filePath: s.filePath,
-        ...(s.startLine !== undefined ? { startLine: s.startLine } : {}),
+        ...(s.startLine !== undefined ? { startLine: toDisplayLine(s.startLine) } : {}),
         ...(s.ambiguous ? { ambiguous: true } : {}),
         ...(s.id === null ? { unresolved: true } : {}),
         pdgEvidence: (s.id === null ? 'degraded' : 'owner-projection'),

package/dist/mcp/resources.js

@@ -365,6 +365,7 @@ additional_node_types: "Multi-language: Struct, Enum, Macro, Typedef, Union, Nam
 
 node_properties:
   common: "name (STRING), filePath (STRING), startLine (INT32), endLine (INT32)"
+  line_numbers: "startLine/endLine on symbol nodes are 0-BASED (tree-sitter rows) in storage AND in raw Cypher results. The context, query, impact, group/cross-repo trace, and explain/pdg_query (symbol anchor) tools present them 1-BASED (editor / sed / less -N aligned), so a symbol spans editor lines (startLine+1)..(endLine+1) — e.g. sed '<startLine+1>,<endLine+1>!d' <file>. Single-repo trace symbol lines stay 0-BASED for now (full-parity follow-up). content holds the exact symbol span. (BasicBlock / PDG statement lines are separately 1-based.) (#2377, #2380)"
   Method: "parameterCount (INT32), returnType (STRING), isVariadic (BOOL), visibility (STRING), isStatic (BOOL), isAbstract (BOOL), isFinal (BOOL), isVirtual (BOOL), isOverride (BOOL), isAsync (BOOL), isPartial (BOOL), requiredParameterCount (INT32), parameterTypes (STRING[]), annotations (STRING[])"
   Function: "parameterCount (INT32), returnType (STRING), isVariadic (BOOL), visibility (STRING), isStatic (BOOL), isAbstract (BOOL), isFinal (BOOL), isAsync (BOOL), parameterTypes (STRING[]), annotations (STRING[])"
   Property: "declaredType (STRING) — the field's type annotation (e.g., 'Address', 'City'). Used for field-access chain resolution."

package/dist/mcp/tools.js

@@ -379,7 +379,7 @@ MODE (opt-in): "callgraph" (default) walks symbol→symbol edges (CALLS/IMPORTS/
 
 STATEMENT-ANCHORED PDG SLICE: with mode:'pdg', pass "line" (1-based source line within the target symbol) to seed the dependence slice on the statement at that line and return what depends on it in affectedStatements (line + text). Inter-procedural symbols are still reported through interproceduralByDepth/pdgInterprocedural and the compatibility byDepth bucket. Without "line", pdg returns whole-symbol inter-procedural reach plus local whole-symbol PDG diagnostics.
 
-PDG OUTPUT CONTRACT: every mode:'pdg' result (success, empty, degraded, or error) carries pdgResultVersion:1 — a stable discriminator for external consumers that bumps on any breaking change to the PDG result shape (distinct from the DB schema version). Successful PDG results include mode:'pdg', a full target envelope (id/name/type/filePath), affectedStatements, affectedStatementCount, interproceduralByDepth/pdgInterprocedural for cross-function reach, compatibility byDepth/byDepthCounts, risk:'UNKNOWN', and a note describing the unified contract. Degraded PDG results (no-layer, sub-layer-missing, unknown) keep mode:'pdg', pdgResultVersion:1, target metadata when the target resolves, risk:'UNKNOWN', note/remediation, and empty byDepth parity fields — never a false-safe zero. If depth and limit both bound the slice, truncatedByReasons reports both causes while truncatedBy remains scalar.
+PDG OUTPUT CONTRACT: every mode:'pdg' result (success, empty, degraded, or error) carries pdgResultVersion:2 — a stable discriminator for external consumers that bumps on any breaking change to the PDG result shape (distinct from the DB schema version). Successful PDG results include mode:'pdg', a full target envelope (id/name/type/filePath), affectedStatements, affectedStatementCount, interproceduralByDepth/pdgInterprocedural for cross-function reach, compatibility byDepth/byDepthCounts, risk:'UNKNOWN', and a note describing the unified contract. Degraded PDG results (no-layer, sub-layer-missing, unknown) keep mode:'pdg', pdgResultVersion:2, target metadata when the target resolves, risk:'UNKNOWN', note/remediation, and empty byDepth parity fields — never a false-safe zero. If depth and limit both bound the slice, truncatedByReasons reports both causes while truncatedBy remains scalar.
 
 WHEN TO USE: Before making code changes — especially refactoring, renaming, or modifying shared code. Shows what would break.
 AFTER THIS: Review d=1 items (WILL BREAK). Use context() on high-risk symbols.

package/dist/storage/repo-manager.d.ts

@@ -242,8 +242,13 @@ export interface RepoMeta {
  * URL-only id). The incremental writeback preserves unchanged-file rows, so a
  * top-up against a pre-v5 index would strand old url-keyed Route nodes alongside
  * new composite-keyed ones — force a full re-analyze instead.
+ * v6: line-number storage flipped to uniform 0-based for the last 1-based
+ * GraphNode emitters — COBOL/JCL/markdown/scope (#2377/#2379/#2380). Incremental
+ * writeback preserves unchanged-file rows, so a top-up against a pre-v6 index
+ * would MIX old 1-based rows with new 0-based ones — and the 1-based MCP display
+ * would render the stale rows one line too high — so force a full re-analyze.
  */
-export declare const INCREMENTAL_SCHEMA_VERSION = 5;
+export declare const INCREMENTAL_SCHEMA_VERSION = 6;
 export interface IndexedRepo {
     repoPath: string;
     storagePath: string;

package/dist/storage/repo-manager.js

@@ -90,8 +90,13 @@ export const registryPathEquals = (a, b) => process.platform === 'win32' ? a.toL
  * URL-only id). The incremental writeback preserves unchanged-file rows, so a
  * top-up against a pre-v5 index would strand old url-keyed Route nodes alongside
  * new composite-keyed ones — force a full re-analyze instead.
+ * v6: line-number storage flipped to uniform 0-based for the last 1-based
+ * GraphNode emitters — COBOL/JCL/markdown/scope (#2377/#2379/#2380). Incremental
+ * writeback preserves unchanged-file rows, so a top-up against a pre-v6 index
+ * would MIX old 1-based rows with new 0-based ones — and the 1-based MCP display
+ * would render the stale rows one line too high — so force a full re-analyze.
  */
-export const INCREMENTAL_SCHEMA_VERSION = 5;
+export const INCREMENTAL_SCHEMA_VERSION = 6;
 const GITNEXUS_DIR = '.gitnexus';
 const GITNEXUS_EXCLUDE_ENTRY = `${GITNEXUS_DIR}/`;
 export const INDEX_METADATA_FILE = 'gitnexus.json';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.10-rc.4",
+  "version": "1.6.10-rc.5",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",