sql-code-graph 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

sqlcg/indexer/git_delta.py

@@ -51,6 +51,7 @@ def git_name_status_delta(root: Path, old_sha: str, new_sha: str) -> Delta | Non
         unknown SHA, shallow clone, or git not available).  Callers MUST fall
         back to a full index_repo when None is returned.
     """
+    root = root.resolve()  # guard: caller may pass a relative path (e.g. Path("."))
     try:
         result = subprocess.run(
             ["git", "diff", "--name-status", old_sha, new_sha],

sqlcg/indexer/indexer.py

@@ -251,9 +251,11 @@ class Indexer:
                     _t_pass2_end = time.perf_counter()
 
         except KeyboardInterrupt:
-            logger.info("SIGINT received — flushing pass-1 progress")
-            # pass1_results may be partial; upsert what we have
-            self._upsert_all(pass1_results, db)
+            # Kill workers and abort immediately. A partial pass-1-only result is
+            # an incomplete graph (no cross-file resolution, no star expansion);
+            # writing it would leave a misleading half-index. Re-run `sqlcg index`
+            # to index — re-indexing is the migration path.
+            logger.warning("Interrupted — workers killed; no partial graph written.")
             raise
 
         # Assemble final pass-2 results: start from pass-1, overlay pass-2 where available
@@ -1104,16 +1106,6 @@ class Indexer:
 
         return counts
 
-    def _upsert_all(self, results: list[ParsedFile], db: GraphBackend) -> None:
-        """Upsert all parsed files.
-
-        Args:
-            results: List of ParsedFile objects
-            db: GraphBackend instance
-        """
-        for parsed in results:
-            self._upsert_parsed_file(parsed, db)
-
     def _expand_star_sources(self, db: GraphBackend) -> int:
         """Run the post-ingestion star expansion query.
 

sqlcg/indexer/pool.py

@@ -194,7 +194,14 @@ class HardKillPool:
     ) -> None:
         self._dialect = dialect
         self._schema_aliases: dict[str, str] = schema_aliases or {}
-        self._n = n_workers or os.cpu_count() or 4
+        # Leave 2 logical cores of headroom rather than spawning one worker per
+        # logical core. Parsing is CPU-bound, and the main process also does work
+        # between passes (closure resolution, batched upserts); saturating every
+        # core makes the largest files miss the per-file wall-clock timeout.
+        # Measured on the 1,453-file DWH corpus (after the once-per-statement parser
+        # fixes): cpu_count → 2 timeouts / 186s; cpu_count-2 → 0 timeouts / 131s
+        # (fewer timeouts AND faster, since timed-out files waste work + respawn churn).
+        self._n = n_workers or max(1, (os.cpu_count() or 4) - 2)
         self._ctx = mp.get_context("spawn")
         self._workers: list[_WorkerState] = []
 
@@ -278,7 +285,9 @@ class HardKillPool:
                 tidx = queue.pop(0)
                 path = tasks[tidx].get("path", "")
                 if kill_counts.get(path, 0) >= poison_retries:
-                    results[tidx] = _timeout_file(path, self._dialect, poison=True)
+                    results[tidx] = _timeout_file(
+                        path, self._dialect, timeout_s=per_task_timeout, poison=True
+                    )
                     logger.warning("Skipping %s — poisoned after %d kills", path, poison_retries)
                     if on_result is not None:
                         on_result()
@@ -322,6 +331,28 @@ class HardKillPool:
             w.task_start = time.monotonic()
             busy.add(slot)
 
+        try:
+            return self._run_map_loop(
+                tasks, results, busy, kill_counts, _assign, per_task_timeout, on_result, n_tasks
+            )
+        except KeyboardInterrupt:
+            # Workers ignore SIGINT and are CPU-bound, so they will not notice a
+            # graceful SHUTDOWN sentinel until their current parse finishes. On
+            # interrupt the user wants the process gone now — hard-kill outright.
+            self.terminate()
+            raise
+
+    def _run_map_loop(
+        self,
+        tasks: list[dict],
+        results: list[ParsedFile | None],
+        busy: set[int],
+        kill_counts: dict[str, int],
+        _assign: Callable[[int], None],
+        per_task_timeout: float,
+        on_result: Callable[[], None] | None,
+        n_tasks: int,
+    ) -> list[ParsedFile | None]:
         # Initial dispatch: fill all worker slots
         for i in range(min(self._n, n_tasks)):
             _assign(i)
@@ -346,7 +377,7 @@ class HardKillPool:
                     slot,
                     kill_counts[path],
                 )
-                results[tidx] = _timeout_file(path, self._dialect)
+                results[tidx] = _timeout_file(path, self._dialect, timeout_s=per_task_timeout)
                 if on_result is not None:
                     on_result()
                 self._respawn(w)
@@ -405,6 +436,31 @@ class HardKillPool:
     # Shutdown
     # ------------------------------------------------------------------
 
+    def terminate(self) -> None:
+        """Immediately SIGKILL every worker without a graceful handshake.
+
+        Unlike :meth:`shutdown`, this sends no ``_SHUTDOWN`` sentinel and does
+        not wait for in-flight parses. Workers ignore SIGINT and are CPU-bound,
+        so a graceful stop would block on the longest running parse; on
+        interrupt we kill outright so the process dies promptly.
+        """
+        for w in self._workers:
+            try:
+                w.conn.close()
+            except Exception:
+                pass
+            try:
+                if w.process.is_alive():
+                    w.process.kill()
+            except Exception:
+                pass
+        for w in self._workers:
+            try:
+                w.process.join(timeout=1)
+            except Exception:
+                pass
+        self._workers.clear()
+
     def shutdown(self) -> None:
         """Gracefully stop all workers, then force-kill any that linger."""
         for w in self._workers:
@@ -432,11 +488,14 @@ class HardKillPool:
 def _timeout_file(
     path: str,
     dialect: str | None,
+    timeout_s: float = 0.0,
     poison: bool = False,
 ) -> ParsedFile:
     pf = ParsedFile(path=Path(path), dialect=dialect)
-    msg = "skipped:poison" if poison else "timeout"
-    pf.errors.append(f"{msg} file={Path(path).name}")
+    if poison:
+        pf.errors.append(f"skipped:poison file={Path(path).name}")
+    else:
+        pf.errors.append(f"timeout:{timeout_s:.0f}s file={Path(path).name}")
     return pf
 
 

sqlcg/parsers/base.py

@@ -619,10 +619,6 @@ class SqlParser(ABC):
             else:
                 return LineageExtraction(edges=edges, star_sources=star_sources)
 
-            # Build scope once from the body for all-column reuse (T-05 optimization)
-            # Defer scope building to just before the column loop to ensure sources
-            # are expanded first (avoid rebuilding for each column, but only build
-            # after sources are known)
             body_scope = None
             combined_sources = {**(sources or {})}
 
@@ -644,8 +640,174 @@ class SqlParser(ABC):
                                 key = cte_alias.lower()
                                 combined_sources[key] = cte.this
 
-            # Extract output columns
-            for col_expr in col_expressions:
+            # Build body_scope ONCE per statement, before the column loop, and reuse
+            # it for every column (CLAUDE.md invariant: "body_scope built once per
+            # statement"). If schema-qualify fails, retry schema-free so we STILL get
+            # a scope for the copy=False fast path; only if both fail do we fall back
+            # to the per-column sources= path. Building this lazily inside the loop
+            # (regressed in 4234e5d) meant a single qualify failure re-ran
+            # expand+qualify+build_scope for EVERY column → O(N_cols) full-body
+            # deepcopies per statement (measured: 229 qualify calls on one 460-line file).
+            if scope is None:
+                expanded_body = body
+                expand_sources = {
+                    k: v for k, v in (sources or {}).items() if isinstance(v, exp.Query)
+                }
+                if expand_sources:
+                    try:
+                        expanded_body = exp.expand(
+                            body,
+                            expand_sources,  # type: ignore
+                            dialect=self.DIALECT,
+                            copy=True,
+                        )
+                    except Exception:
+                        expanded_body = body
+                try:
+                    qualified_body = qualify(
+                        expanded_body,
+                        dialect=self.DIALECT,
+                        schema=schema,
+                        validate_qualify_columns=False,
+                        identify=False,
+                    )
+                    body_scope = build_scope(qualified_body)
+                except Exception as _qualify_exc:
+                    out.errors.append(
+                        f"col_lineage_skip:qualify_failed:{type(_qualify_exc).__name__}"
+                    )
+                    # Schema-free retry: still yields a scope for the copy=False path.
+                    try:
+                        qualified_body = qualify(
+                            expanded_body,
+                            dialect=self.DIALECT,
+                            validate_qualify_columns=False,
+                            identify=False,
+                        )
+                        body_scope = build_scope(qualified_body)
+                    except Exception:
+                        body_scope = None
+
+            # INSERT positional column-list mapping (#25 fix).
+            # Compute the positional_col_names skip-set BEFORE the main column loop
+            # so the main loop can skip positions already handled here.
+            #
+            # When an INSERT has an explicit column list (INSERT INTO t (c1, c2) SELECT ...),
+            # the target column name at position idx is authoritative — the SELECT alias is
+            # cosmetic for the SELECT and meaningless to the INSERT target. This block
+            # overrides alias attribution for ALL positions (aliased or not).
+            #
+            # Guards applied here mirror the main column loop to preserve skip markers:
+            #   - Star expressions → emit col_lineage_skip:star, register pos, skip sg_lineage
+            #   - Pure-literal (no Column descendant) → register pos, skip sg_lineage (silent)
+            #   - Unaliased non-Column (func/arith/CASE) → emit col_lineage_skip:func_fallback,
+            #     register pos, skip sg_lineage
+            #   - Plain Column / aliased expression → call sg_lineage (the #25 happy path)
+            #
+            # CLAUDE.md invariant: body_no_with = body.copy() + strip-WITH happens ONCE
+            # before the inner loop; only the single projection is swapped per column.
+            positional_col_names: dict[int, str] = {}  # idx → insert_col_name
+            if isinstance(stmt, exp.Insert) and isinstance(stmt.this, exp.Schema):
+                insert_cols_list = [c.name for c in stmt.this.expressions]
+                # Build the WITH-stripped body ONCE here, before any per-column loop.
+                # Only the single projection is swapped per column below.
+                body_no_with = body.copy()
+                body_no_with.set("with_", None)
+                for _ins_idx, _col_expr in enumerate(col_expressions):
+                    if _ins_idx >= len(insert_cols_list):
+                        break
+                    _insert_col = insert_cols_list[_ins_idx]
+                    if not _insert_col:
+                        continue
+                    # Register position first so the main loop always skips it,
+                    # regardless of which guard fires below.
+                    positional_col_names[_ins_idx] = _insert_col
+
+                    # Guard 1: Star projection — emit skip marker (same as main loop).
+                    _inner_for_guard = (
+                        _col_expr.this if isinstance(_col_expr, exp.Alias) else _col_expr
+                    )
+                    if isinstance(_inner_for_guard, exp.Star) or (
+                        isinstance(_inner_for_guard, exp.Column)
+                        and isinstance(_inner_for_guard.this, exp.Star)
+                    ):
+                        _qualifier = (
+                            _inner_for_guard.table
+                            if isinstance(_inner_for_guard, exp.Column)
+                            else None
+                        )
+                        out.errors.append(f"col_lineage_skip:star:{_qualifier or '<unqualified>'}")
+                        continue  # no sg_lineage for star
+
+                    # Guard 2: Pure-literal — no Column descendants, nothing to trace.
+                    if not list(_col_expr.find_all(exp.Column)):
+                        continue  # silent skip, no sg_lineage
+
+                    # NOTE: do NOT emit func_fallback here for unaliased non-Column
+                    # expressions (functions, arithmetic, CASE …). The main loop emits
+                    # func_fallback for such expressions because a plain SELECT/CREATE VIEW
+                    # gives them no output column name. The positional INSERT column list
+                    # DOES supply that name (_insert_col): below we wrap the expression as
+                    # Alias(expr, _insert_col) and let sg_lineage trace through it — exactly
+                    # as the aliased form (e.g. `DATE(col) AS a`) already resolves. Guard 2
+                    # (above) already dropped genuinely-untraceable pure-literal expressions
+                    # (no Column descendant). Skipping column-containing expressions here would
+                    # make the #25 positional feature do its work and then discard the result,
+                    # dropping real lineage edges (regressed by eb19f29; broke COALESCE).
+
+                    # Positional mapping always wins — replace (or add) the alias with the
+                    # INSERT target column name regardless of SELECT alias.
+                    if _col_expr.alias and _col_expr.alias != _insert_col:
+                        self._log.debug(
+                            "INSERT positional override: SELECT alias %r → INSERT col %r"
+                            " at position %d",
+                            _col_expr.alias,
+                            _insert_col,
+                            _ins_idx,
+                        )
+                    # If the expression is already an Alias(inner, old_alias), unwrap it
+                    # before re-wrapping — otherwise we produce Alias(Alias(inner, x), c1)
+                    # which serialises as "inner AS x AS c1" (syntax error).
+                    _inner = _col_expr.this if isinstance(_col_expr, exp.Alias) else _col_expr
+                    _aliased = exp.Alias(this=_inner.copy(), alias=_insert_col)
+                    body_no_with.set("expressions", [_aliased])
+                    _patched_sql = body_no_with.sql(dialect=self.DIALECT)
+                    # Pass sources= (not scope=) here: the patched SQL is a freshly
+                    # serialised string — the scope was built from the original body AST
+                    # and does not correspond to this new string.
+                    #
+                    # Use `sources` (the cross-statement temp/CTAS map), NOT
+                    # `combined_sources`. combined_sources additionally carries the
+                    # SAME-STATEMENT CTE bodies (added above). Since body_no_with strips
+                    # the WITH clause from the patched SQL, those CTE names become opaque
+                    # source relations — passing their bodies as sources= would expand them
+                    # away, collapsing intermediate CTE→target hops into the deepest source
+                    # (regressed by eb19f29; broke the MA_AANTAL_OP_ORDER anchor link 5).
+                    # Cross-statement temps (e.g. CREATE TEMP TABLE t) live in `sources`
+                    # and SHOULD still expand (E36 multi-temp: t → src).
+                    try:
+                        _root = sg_lineage(
+                            _insert_col,
+                            _patched_sql,
+                            dialect=self.DIALECT,
+                            sources=sources or {},
+                        )
+                        if _root:
+                            _new_edges = self._lineage_node_to_edges(
+                                _root,
+                                dst_col_name=_insert_col,
+                                dst_table=dst_table,
+                                path=path,
+                                out=out,
+                            )
+                            edges.extend(_new_edges)
+                    except Exception:
+                        pass
+
+            # Extract output columns — skip positions handled by the positional INSERT block
+            for loop_idx, col_expr in enumerate(col_expressions):
+                if loop_idx in positional_col_names:
+                    continue  # positional INSERT block already emitted this column
                 # Skip star projections — sg_lineage requires a concrete column name.
                 if isinstance(col_expr, exp.Star) or (
                     isinstance(col_expr, exp.Column) and isinstance(col_expr.this, exp.Star)
@@ -723,53 +885,23 @@ class SqlParser(ABC):
                         continue
 
                 try:
-                    # Build scope on first column for reuse across all columns (T-05 optimization).
-                    # NOTE: We build body_scope locally from the extracted body rather than
-                    # using a pre-built scope from the statement, because CREATE/INSERT statements
-                    # have their scope rooted at the outer statement, but the body passed here
-                    # is the inner SELECT. Reusing the outer scope would produce incorrect
-                    # qualification. The pre-built scope from parse_file would only be useful
-                    # if we had a mechanism to extract the matching inner scope, which is
-                    # complex and not yet implemented (see sprint_06 T-05 deviation for details).
-                    if body_scope is None and scope is None:
-                        try:
-                            # Expand only file-level sources (CTEs, temp tables, CTAS bodies).
-                            expanded_body = body
-                            expand_sources = {
-                                k: v for k, v in (sources or {}).items() if isinstance(v, exp.Query)
-                            }
-                            if expand_sources:
-                                expanded_body = exp.expand(
-                                    body,
-                                    expand_sources,  # type: ignore
-                                    dialect=self.DIALECT,
-                                    copy=True,
-                                )
-
-                            # Qualify the expanded body to prepare for scope building
-                            qualified_body = qualify(
-                                expanded_body,
-                                dialect=self.DIALECT,
-                                schema=schema,
-                                validate_qualify_columns=False,
-                                identify=False,
-                            )
-                            body_scope = build_scope(qualified_body)
-                        except Exception as _qualify_exc:
-                            # qualify() failure is non-fatal: sg_lineage falls back to
-                            # its own qualification. Record for observability.
-                            out.errors.append(
-                                f"col_lineage_skip:qualify_failed:{type(_qualify_exc).__name__}:{_qualify_exc}"
-                            )
-                            body_scope = None
-
                     # When a scope is available it embeds full column→table resolution.
                     # On the qualify-failed fallback path (no scope), pass only the small
                     # set of file-level sources so sg_lineage can resolve CTEs/CTAS bodies.
                     active_scope = scope if scope is not None else body_scope
                     sg_kwargs: dict = {"dialect": self.DIALECT}
                     if active_scope is not None:
+                        # scope= path: the pre-built scope already embeds full
+                        # column→table resolution. copy=False + trim_selects=False
+                        # suppress sqlglot's per-call AST deepcopy and per-column
+                        # trim — neither is needed when the scope is built once and
+                        # reused across all columns. Dropping these (regressed in
+                        # 4234e5d) makes lineage() deepcopy the whole scope per
+                        # column → O(columns × scope_size) (measured: 3.2M deepcopy
+                        # calls / ~3.8s on a 359-line file).
                         sg_kwargs["scope"] = active_scope
+                        sg_kwargs["copy"] = False
+                        sg_kwargs["trim_selects"] = False
                     else:
                         sg_kwargs["sources"] = sources or {}
                     root = sg_lineage(col_name, body, **sg_kwargs)
@@ -905,42 +1037,6 @@ class SqlParser(ABC):
                                         cte_col_name,
                                     )
 
-            # INSERT column-list aliasing (T-07-02 link 5).
-            # When an INSERT has an explicit column list and the SELECT expression has
-            # no alias (e.g. SELECT SUM(x) FROM cte), the INSERT column at the same
-            # position provides the destination col name. Stripping the WITH clause
-            # stops sg_lineage at the CTE name boundary (doesn't expand into bodies).
-            if isinstance(stmt, exp.Insert) and isinstance(stmt.this, exp.Schema):
-                insert_cols = [c.name for c in stmt.this.expressions]
-                for idx, col_expr in enumerate(col_expressions):
-                    if idx >= len(insert_cols):
-                        break
-                    if col_expr.alias:
-                        continue  # already handled by the main col loop
-                    insert_col = insert_cols[idx]
-                    if not insert_col:
-                        continue
-                    # Build a patched SELECT: strip WITH, alias the expression with the
-                    # INSERT column name so sg_lineage can trace it.
-                    body_no_with = body.copy()
-                    body_no_with.set("with_", None)
-                    aliased = exp.Alias(this=col_expr.copy(), alias=insert_col)
-                    body_no_with.set("expressions", [aliased])
-                    patched_sql = body_no_with.sql(dialect=self.DIALECT)
-                    try:
-                        root = sg_lineage(insert_col, patched_sql, dialect=self.DIALECT)
-                        if root:
-                            new_edges = self._lineage_node_to_edges(
-                                root,
-                                dst_col_name=insert_col,
-                                dst_table=dst_table,
-                                path=path,
-                                out=out,
-                            )
-                            edges.extend(new_edges)
-                    except Exception:
-                        pass
-
         except Exception as exc:
             self._log.debug(
                 "column lineage extraction failed for entire statement: file=%s error=%s",

sqlcg/server/server.py

@@ -1,35 +1,76 @@
 """MCP server for SQL Code Graph.
 
 Exposes FastMCP tools for lineage queries, pattern search, and indexing.
-MCP protocol uses stdout for message transport, so this module redirects
-stdout to stderr to prevent user logs from corrupting the protocol stream.
+MCP protocol uses stdout (fd 1) for JSON-RPC message transport. This module
+captures fd 1 as a raw binary buffer BEFORE any logging redirection so that
+the captured buffer can be passed explicitly to stdio_server(). This ensures
+JSON-RPC frames always go to fd 1 regardless of what sys.stdout points to
+at call time.
+
+Ordering invariant (must not change):
+  1. os.dup(1) → _real_stdout_buffer        (first — before everything)
+  2. from mcp.server import FastMCP          (module-level import)
+  3. mcp = FastMCP("SQL Code Graph")         (module-level; tools.py registers here)
+  4. main() calls _configure_mcp_logging()   (not at module scope)
 """
 
+import os
 import sys
 
-from dotenv import load_dotenv
-from mcp.server import FastMCP
+# Capture the real fd 1 binary stream FIRST — before _configure_mcp_logging()
+# (which replaces sys.stdout) AND before FastMCP("SQL Code Graph") construction.
+# stdio_server() receives this explicitly so JSON-RPC frames go to fd 1
+# regardless of what sys.stdout points to afterward.
+# Guards against the v1.0.0/v1.0.1 regression where frames went to fd 2.
+_real_stdout_buffer = os.fdopen(os.dup(1), "wb", buffering=0)
 
-from sqlcg.utils.logging import getLogger
+from dotenv import load_dotenv  # noqa: E402
+from mcp.server import FastMCP  # noqa: E402
+
+from sqlcg.utils.logging import getLogger  # noqa: E402
 
 logger = getLogger(__name__)
 
+# Create FastMCP instance at module scope so tools.py can import and register with it.
+# This is safe because _real_stdout_buffer has already captured fd 1 above.
+mcp = FastMCP("SQL Code Graph")
+
 
 def _configure_mcp_logging() -> None:
-    """Redirect sys.stdout to sys.stderr to protect MCP protocol.
+    """Redirect sys.stdout to sys.stderr and configure logging to stderr.
 
-    MCP uses stdout for JSON-RPC messages. Any user print() or log output
-    to stdout would corrupt the protocol. This function must be called before
-    mcp.run() and before any code that might print to stdout.
+    sys.stdout is replaced with sys.stderr so that any stray print() call
+    does not pollute fd 1 (reserved for MCP JSON-RPC frames).
+    The real fd 1 binary stream is captured in _real_stdout_buffer at module
+    top before this replacement and passed explicitly to stdio_server().
+
+    Must be called inside main(), not at module scope, so that
+    _real_stdout_buffer captures fd 1 before the redirect.
     """
+    import logging
+
     sys.stdout = sys.stderr
+    logging.basicConfig(stream=sys.stderr, level=logging.WARNING)
 
 
-# Protect stdout before importing FastMCP (which may emit output during import)
-_configure_mcp_logging()
+async def _run_stdio_async_with_real_stdout() -> None:
+    """Run the MCP server loop with JSON-RPC frames explicitly on fd 1.
 
-# Create FastMCP instance at module scope so tools.py can import and register with it
-mcp = FastMCP("SQL Code Graph")
+    Bypasses FastMCP.run_stdio_async() (which uses sys.stdout at call time)
+    and drives the server loop directly with the captured _real_stdout_buffer.
+    """
+    from io import TextIOWrapper
+
+    import anyio
+    from mcp.server.stdio import stdio_server
+
+    stdout_text = TextIOWrapper(_real_stdout_buffer, encoding="utf-8", line_buffering=False)
+    async with stdio_server(stdout=anyio.wrap_file(stdout_text)) as (read_stream, write_stream):
+        await mcp._mcp_server.run(
+            read_stream,
+            write_stream,
+            mcp._mcp_server.create_initialization_options(),
+        )
 
 
 def main(db_path: str | None = None) -> None:
@@ -38,10 +79,13 @@ def main(db_path: str | None = None) -> None:
     Args:
         db_path: Path to KùzuDB database. If None, uses SQLCG_DB_PATH env var
                 or ~/.sqlcg/graph.db (via get_db_path in tools module).
-
-    Raises:
-        RuntimeError: If tools fail to initialize or FastMCP server fails.
     """
+    import anyio
+
+    # Must be first — redirects sys.stdout → sys.stderr so stray prints don't
+    # corrupt fd 1. _real_stdout_buffer was already captured at module top.
+    _configure_mcp_logging()
+
     load_dotenv()
 
     # Import tools module to trigger tool registration via @mcp.tool() decorators
@@ -50,8 +94,7 @@ def main(db_path: str | None = None) -> None:
     # Initialize the backend singleton used by all tools
     sqlcg.server.tools.init_backend(db_path)
 
-    # Run the MCP server event loop, ensuring backend is closed on shutdown
     try:
-        mcp.run()
+        anyio.run(_run_stdio_async_with_real_stdout)
     finally:
         sqlcg.server.tools.shutdown_backend()

sqlcg/server/tools.py

@@ -183,6 +183,19 @@ def _assert_indexed(db: GraphBackend) -> None:
         )
 
 
+def _bare_ref(ref: str) -> str:
+    """Strip schema prefix from a ref string, keeping table.column.
+
+    For a 3-part ref ("mart.fact_t.amount") this returns "fact_t.amount".
+    For a 2-part ref ("fact_t.amount") this returns the ref unchanged.
+    Never uses rsplit — that would yield only the column name for 3-part refs.
+    """
+    parts = ref.split(".")
+    if len(parts) >= 3:
+        return ".".join(parts[1:])  # drop schema, keep table.column
+    return ref  # already bare (no schema prefix)
+
+
 def _parse_column_ref(col_ref: str) -> tuple[str, str]:
     """Parse column reference "table.column" or "catalog.db.table.column".
 
@@ -554,9 +567,54 @@ def trace_column_lineage(table_col: str, max_depth: int | None = None) -> Lineag
 
         mermaid = _build_mermaid(col_id, edges) if edges else None
 
+        # Bare-name fallback: when the primary query returns empty and the ref has a
+        # schema component (3+ parts), retry with the schema prefix stripped.
+        # This handles unqualified INSERT targets indexed without a schema prefix.
+        bare_fallback_used = False
+        if not lineage and len(table_col.split(".")) >= 3:
+            bare = _bare_ref(table_col)
+            bare_queue: deque[tuple[str, int]] = deque([(bare, 0)])
+            bare_visited: set[str] = set()
+            bare_emitted: set[str] = set()
+            while bare_queue:
+                current_id, depth = bare_queue.popleft()
+                if current_id in bare_visited or (max_depth is not None and depth > max_depth):
+                    continue
+                if len(bare_visited) >= max_nodes:
+                    break
+                bare_visited.add(current_id)
+                rows = db.run_read(TRACE_COLUMN_LINEAGE_QUERY, {"id": current_id})
+                for row in rows:
+                    node_id = row["id"]
+                    edges.append((node_id, current_id, row.get("transform") or "SELECT"))
+                    if node_id not in bare_visited and node_id not in bare_emitted:
+                        bare_emitted.add(node_id)
+                        lineage.append(
+                            LineageNode(
+                                name=row.get("col_name", ""),
+                                kind="column",
+                                table=row.get("table_qualified"),
+                                file=None,
+                                confidence=row.get("confidence"),
+                            )
+                        )
+                    if node_id not in bare_visited:
+                        bare_queue.append((node_id, depth + 1))
+            if lineage:
+                bare_fallback_used = True
+                mermaid = _build_mermaid(bare, edges) if edges else None
+
         # Populate hint if result is empty (Step 4.1)
         hint = None
-        if not lineage:
+        if bare_fallback_used:
+            bare = _bare_ref(table_col)
+            hint = (
+                f"No results for '{table_col}'. Found lineage under bare name '{bare}'. "
+                "The INSERT target may have been indexed without a schema prefix. "
+                "Multiple tables with the same unqualified name in different schemas "
+                "would all match — re-index with an explicit schema for precise results."
+            )
+        elif not lineage:
             hint = (
                 "No lineage found. Ensure the column reference includes the schema prefix "
                 "(e.g., ba.table_name.column_name). Check that 'sqlcg db info' shows "

sqlcg/utils/ignore.py

@@ -14,6 +14,7 @@ def load_ignore_spec(root: Path) -> pathspec.PathSpec:
     Returns:
         PathSpec object for matching ignore patterns
     """
+    root = Path(root).resolve()  # guard: caller may pass a relative path (e.g. Path("."))
     ignore_file = root / ".sqlcgignore"
     if ignore_file.exists():
         patterns = ignore_file.read_text().splitlines()
@@ -33,4 +34,5 @@ def is_ignored(path: Path, root: Path, spec: pathspec.PathSpec) -> bool:
     Returns:
         True if the path matches any ignore pattern
     """
+    root = Path(root).resolve()  # guard: ensure root is absolute before relative_to()
     return spec.match_file(str(path.relative_to(root)))