codegraph-brain 0.29.0__tar.gz → 0.31.0__tar.gz

codegraph_brain-0.31.0/.github/test-count-baseline

@@ -0,0 +1 @@
+3417

{codegraph_brain-0.29.0 → codegraph_brain-0.31.0}/.github/workflows/ci.yml

@@ -162,6 +162,20 @@ jobs:
           # this exemption hides it — that is the cost, and it is the reason the
           # rule stays on for src/.
           #
+          # pythonsecurity:S8706 (connection-string injection) is the same
+          # finding at sqlite3.connect: graph_identity.py opens a database named
+          # on its own command line. `dump()` requires an existing .db/.sqlite/
+          # .sqlite3 regular file before connecting, and passes no `uri=True`, so
+          # the argument is a file name and never a connection string. Exempted
+          # for scripts/ on the S2083 reasoning above — the engine does not model
+          # the check — and kept on for src/.
+          #
+          # tests/fixtures/ is excluded from test analysis
+          # (`sonar.test.exclusions`; it sits under `sonar.tests`, so
+          # `sonar.exclusions` would not reach it): it holds input corpora, not
+          # code. Its package.json files exist to be parsed by cgis, and a lock
+          # file next to them (text:S8564) would be a fixture nothing reads.
+          #
           # `sonar.newCode.referenceBranch` overrides the server-side new-code
           # definition for this analysis. The instance default is
           # `previous_version` (confirmed: sonar.leak.period=previous_version,
@@ -218,13 +232,16 @@ jobs:
             -Dsonar.newCode.referenceBranch=main
             -Dsonar.sources=src,scripts,.github
             -Dsonar.tests=tests
+            -Dsonar.test.exclusions=tests/fixtures/**
             -Dsonar.python.version=3.12
             -Dsonar.python.coverage.reportPaths=coverage.xml
-            -Dsonar.issue.ignore.multicriteria=e1,e2,e3,e4
+            -Dsonar.issue.ignore.multicriteria=e1,e2,e3,e4,e5
             -Dsonar.issue.ignore.multicriteria.e1.ruleKey=pythonsecurity:S8707
             -Dsonar.issue.ignore.multicriteria.e1.resourceKey=scripts/**/*.py
             -Dsonar.issue.ignore.multicriteria.e4.ruleKey=pythonsecurity:S2083
             -Dsonar.issue.ignore.multicriteria.e4.resourceKey=scripts/**/*.py
+            -Dsonar.issue.ignore.multicriteria.e5.ruleKey=pythonsecurity:S8706
+            -Dsonar.issue.ignore.multicriteria.e5.resourceKey=scripts/**/*.py
             -Dsonar.issue.ignore.multicriteria.e2.ruleKey=githubactions:S8541
             -Dsonar.issue.ignore.multicriteria.e2.resourceKey=.github/workflows/*.yml
             -Dsonar.issue.ignore.multicriteria.e3.ruleKey=githubactions:S8544

{codegraph_brain-0.29.0 → codegraph_brain-0.31.0}/.gitignore

@@ -15,6 +15,8 @@ downloads/
 eggs/
 .eggs/
 lib/
+# The graph-identity corpus has lib/ directories that are inputs, not build output.
+!tests/fixtures/graph_identity/corpus/**/lib/
 lib64/
 parts/
 sdist/

{codegraph_brain-0.29.0 → codegraph_brain-0.31.0}/.pre-commit-config.yaml

@@ -40,6 +40,7 @@ repos:
           - tree-sitter>=0.25.2
           - tree-sitter-python>=0.25.0
           - tree-sitter-typescript>=0.23.2
+          - tree-sitter-go>=0.25.0
           - pytest>=9.0.3
           - "mcp[cli]>=2"  # must match the pyproject bound
           - duckdb>=1.1.0

codegraph_brain-0.31.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.31.0"
+}

{codegraph_brain-0.29.0 → codegraph_brain-0.31.0}/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## [0.31.0](https://github.com/zaebee/codegraph-brain/compare/codegraph-brain-v0.30.0...codegraph-brain-v0.31.0) (2026-10-16)
+
+
+### Features
+
+* **bench:** score Go method spellings ([#653](https://github.com/zaebee/codegraph-brain/issues/653)) ([3eccec7](https://github.com/zaebee/codegraph-brain/commit/3eccec74a01af9c128431714d47270badf739e7c))
+* **go:** interface satisfaction compares arity, not just names ([#651](https://github.com/zaebee/codegraph-brain/issues/651)) ([05a8dd2](https://github.com/zaebee/codegraph-brain/commit/05a8dd2b5d7486733d74d9c139519c873a43d523))
+* **go:** interface satisfaction dispatches; embedding no longer does ([#647](https://github.com/zaebee/codegraph-brain/issues/647)) ([ff785f7](https://github.com/zaebee/codegraph-brain/commit/ff785f7e40a91e159266d1c7cb38ed912a1ed676))
+* **query:** a DISPATCHES hop costs no traversal depth ([#649](https://github.com/zaebee/codegraph-brain/issues/649)) ([b5c9ed9](https://github.com/zaebee/codegraph-brain/commit/b5c9ed91bec8b7c857e17f974f5d351c0c745094))
+* **query:** coverage note screens test callers and says where each gap is ([#644](https://github.com/zaebee/codegraph-brain/issues/644)) ([814a679](https://github.com/zaebee/codegraph-brain/commit/814a67904f980048f9d699f14408b6f4a3732c4f))
+
+
+### Bug Fixes
+
+* **logging:** the CLI and the MCP server log to stderr ([#619](https://github.com/zaebee/codegraph-brain/issues/619)) ([#622](https://github.com/zaebee/codegraph-brain/issues/622)) ([3fc1db2](https://github.com/zaebee/codegraph-brain/commit/3fc1db20d5c8a1cdb5793d357550c7854f499161))
+* **resolver:** an Any-typed receiver declares no type ([#638](https://github.com/zaebee/codegraph-brain/issues/638)) ([4cb43b6](https://github.com/zaebee/codegraph-brain/commit/4cb43b676e43a82b3a9edf3a6175e34623b68bba))
+
+
+### Documentation
+
+* **lab-notes:** exp1 — change radius and indirection vs agent cost (pre-registered) ([#633](https://github.com/zaebee/codegraph-brain/issues/633)) ([b6c002c](https://github.com/zaebee/codegraph-brain/commit/b6c002c9522a863b2412c06ca5130f622887ee40))
+* **lab-notes:** exp2 — indirection at fixed radius and answer size, on cgis (pre-registered) ([#634](https://github.com/zaebee/codegraph-brain/issues/634)) ([c74c90d](https://github.com/zaebee/codegraph-brain/commit/c74c90d6dd4e13d5fcd52339ed7b699bce6fa535))
+* **lab-notes:** exp3 — does cgis help an agent (pre-registered, kill criterion) ([#635](https://github.com/zaebee/codegraph-brain/issues/635)) ([507ada5](https://github.com/zaebee/codegraph-brain/commit/507ada5561147b7ec94fab9e8a3a21eb673755eb))
+* **lab-notes:** exp3b — rerun after the [#636](https://github.com/zaebee/codegraph-brain/issues/636) fix (pre-registered) ([#640](https://github.com/zaebee/codegraph-brain/issues/640)) ([c5cb290](https://github.com/zaebee/codegraph-brain/commit/c5cb290eb993cbf7fcee78c092d7f6bb61aa22b0))
+
+## [0.30.0](https://github.com/zaebee/codegraph-brain/compare/codegraph-brain-v0.29.0...codegraph-brain-v0.30.0) (2026-10-15)
+
+
+### Features
+
+* **languages:** Go field and call-result types resolve receiver calls ([#608](https://github.com/zaebee/codegraph-brain/issues/608)) ([#614](https://github.com/zaebee/codegraph-brain/issues/614)) ([96ec5f3](https://github.com/zaebee/codegraph-brain/commit/96ec5f380d52ba1560c63b8b84af673627bc88d0))
+* **languages:** step 7b — the Go pilot ([#607](https://github.com/zaebee/codegraph-brain/issues/607)) ([4a62703](https://github.com/zaebee/codegraph-brain/commit/4a62703f41a4dfb74d1f96bee132b3f78f84c895))
+* **pipeline:** a graph built by other extraction code is rebuilt in full ([#617](https://github.com/zaebee/codegraph-brain/issues/617)) ([dc33153](https://github.com/zaebee/codegraph-brain/commit/dc331531556cc2dc49c8adfacbec079584953eb8))
+* **python:** FastAPI handlers play the ROUTE_HANDLER role ([#566](https://github.com/zaebee/codegraph-brain/issues/566)) ([#616](https://github.com/zaebee/codegraph-brain/issues/616)) ([9098ccd](https://github.com/zaebee/codegraph-brain/commit/9098ccd87ef08fbb3139243fda426b62e8d1b32b))
+
+
+### Bug Fixes
+
+* **docs:** coverage claims name Go — the MCP instructions are built from the registry ([#615](https://github.com/zaebee/codegraph-brain/issues/615)) ([8ea6362](https://github.com/zaebee/codegraph-brain/commit/8ea636239122b24c4a42b2a65517ebb12dad1b03))
+
+
+### Documentation
+
+* auto-sync architecture graph and MCP reference ([#598](https://github.com/zaebee/codegraph-brain/issues/598)) ([3feb1ac](https://github.com/zaebee/codegraph-brain/commit/3feb1ac40b1896acb0e57109c9bd1f2bf941d7bc))
+* auto-sync architecture graph and MCP reference ([#620](https://github.com/zaebee/codegraph-brain/issues/620)) ([3f36e15](https://github.com/zaebee/codegraph-brain/commit/3f36e15c30dca7280b57bebd70a8793764cd872e))
+* **spec:** language packs and a two-plane topology ([#593](https://github.com/zaebee/codegraph-brain/issues/593)) ([d9e7d85](https://github.com/zaebee/codegraph-brain/commit/d9e7d852b17d4cab4a2a4a0f2519f11f8de9236e))
+
 ## [0.29.0](https://github.com/zaebee/codegraph-brain/compare/codegraph-brain-v0.28.0...codegraph-brain-v0.29.0) (2026-10-14)
 
 

{codegraph_brain-0.29.0 → codegraph_brain-0.31.0}/CLAUDE.md

@@ -45,21 +45,24 @@ make coverage-html   # same, writes htmlcov/
 The pipeline runs in three phases: **Extract → Resolve → Store**.
 
 ```
-IngestionPipeline (pipeline.py)
-  ├── BaseExtractor subclasses (extractors/)   ← language-specific AST → Nodes+Edges
-  │     └── PythonExtractor                    ← only language implemented so far
+IngestionPipeline (pipeline/__init__.py)
+  ├── cgis.languages (registry)                ← lazy: a pack is imported when its first file is met
+  │     ├── languages/python/                  ← PythonExtractor + PACK
+  │     ├── languages/typescript/              ← TypeScriptExtractor (.ts/.tsx) + PACK
+  │     └── languages/go/                      ← GoExtractor (.go) + go.mod reader + PACK (pilot)
   ├── ResolverEngine (resolver/engine.py)      ← raw_call: targets → resolved FQN edges
-  └── SQLiteStore (storage/sqlite_store.py)    ← persists graph; WAL mode
+  ├── SQLiteStore (storage/sqlite_store.py)    ← persists graph; WAL mode
+  └── post-write passes (pipeline/)            ← refresh_dispatch, SemanticUpliftEngine (pipeline/uplift.py)
         └── QueryEngine (query/engine.py)      ← BFS traversals (impact / flow)
 ```
 
-**Node FQN format**: `module.ClassName.method_name` — fully dot-separated, derived from the file path (e.g., `src/cgis/pipeline.py` → `src.cgis.pipeline.IngestionPipeline.run`). Use `file_path_to_module_fqn(path)` from `extractors/python_extractor.py` to convert paths. `__init__.py` strips the `/__init__` suffix.
+**Node FQN format**: `module.ClassName.method_name` — fully dot-separated, derived from the file path (e.g., `src/cgis/pipeline.py` → `src.cgis.pipeline.IngestionPipeline.run`). Use `cgis.languages.scope_of(path, source_root)` to convert paths (it picks the file's own pack; the Python rule lives in `languages/python/extractor.py`). `__init__.py` strips the `/__init__` suffix.
 
 **Raw call convention**: Extractors emit edges with `target = "raw_call:<name>"`. The `ResolverEngine` then resolves these to actual FQNs or leaves them unresolved (keeps the `raw_call:` prefix in output).
 
 **`ResolverEngine` resolution order** for a call to `name`:
 1. `self.method` → look up `method` on the enclosing class via `_class_methods` index
-2. Unqualified call → `_global_symbols` by name; if ambiguous, prefer same-file candidate via `_file_global_symbols`
+2. Unqualified call → `_global_symbols` by name; if ambiguous, prefer the same-scope candidate via `file_global_symbols` (a file's scope is its path, or the `metadata["scope"]` its FILE node declares — a Go package)
 
 ## Core Models (`src/cgis/core/models.py`)
 
@@ -68,12 +71,31 @@ IngestionPipeline (pipeline.py)
 - `NodeType` — structural (`FILE`, `MODULE`, `CLASS`, `FUNCTION`, `METHOD`…), runtime (`API_ENDPOINT`, `DB_TABLE`…), semantic (`DOMAIN_CONCEPT`).
 - `EdgeType` — structural (`CONTAINS`, `DECLARES`, `IMPORTS`), behavioral (`CALLS`, `REFERENCES`), semantic (`HANDLES`, `PERSISTS`, `AUTHORIZES`).
 
-## Adding a New Language Extractor
-
-1. Subclass `BaseExtractor` in `src/cgis/extractors/`.
-2. Implement `parse(code: str, file_path: str) -> tuple[list[Node], list[Edge]]`.
-3. Emit `CALLS` edges with `target="raw_call:<name>"` — the resolver handles the rest.
-4. Register the extractor in `cli.py`'s `extractors` dict with the file extension key.
+## Adding a Language Pack
+
+1. Create `src/cgis/languages/<name>/` with an extractor subclassing `cgis.core.extractor.BaseExtractor`
+   (`parse(code, file_path) -> tuple[list[Node], list[Edge]]`; emit `CALLS` edges with
+   `target="raw_call:<name>"`, set `Node.language = "<name>"`).
+2. In its `__init__.py`, define `PACK`, subclassing `cgis.core.extractor.LanguagePack` (mark methods `@override`)
+   (`name`, `extensions`, `code_fence`, `is_test`, `scope_of`, `extractor`, `project_reader`,
+   `index_facts`, `classify`, `resolution`). `resolution()` returns `ResolutionRules`
+   (`cgis.core.resolution`): type normalizers, steps at a position (`after:import_map`), a
+   fallback with its confidence, `reconcile_import`, and optionally `dispatch` (which methods a call through
+   another type's may run; default: class hierarchy) — all reading the index as `ResolutionView`.
+   Metadata other files resolve against goes in the manifest's `cross_file_metadata`. `classify` answers for references from the pack's own files and
+   runs the whole chain; a source with no pack gets the generic tail in `SymbolIndex.classify_fqn`.
+3. Add one `Manifest` to `MANIFESTS` in `src/cgis/languages/__init__.py`, with a `load` function that
+   imports the pack statically inside it (lazy, yet visible to the review-fingerprint walk). Nothing
+   else names the pack: CLI, MCP server, guardian and scripts all go through the registry, and the
+   `surface-packs` forbidden-edge gate fails if a surface imports a pack directly.
+4. A pack never imports another pack or `cgis.storage` (`cross-pack`, `pack-isolation` gates).
+5. A pack's `__init__` imports no grammar: import the extractor inside `extractor()`. Config reading
+   goes in a `ProjectReader` (`cgis.core.project`) whose facts are data keyed by `ingest_state`
+   key — the collector (`cgis.import_names`), not the pack, writes them. A key other than the four
+   built-ins (`_FACT_SHAPES`) travels as `ImportNames.extra`: recorded, compared, and merged into the
+   `state` the pack's `index_facts` reads. Its value must read back equal from JSON (no tuples).
+6. A FILE node's id comes from `file_node_id`, its definitions' namespace from `scope_of`; they differ
+   only where several files share a scope (Go), which the FILE node declares as `metadata["scope"]`.
 
 ## Type Discipline
 

{codegraph_brain-0.29.0 → codegraph_brain-0.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codegraph-brain
-Version: 0.29.0
+Version: 0.31.0
 Summary: Semantic code graph for AI agents — deterministic FQN resolution, impact analysis and architectural drift gates, exposed over MCP.
 Project-URL: Homepage, https://github.com/zaebee/codegraph-brain
 Project-URL: Repository, https://github.com/zaebee/codegraph-brain
@@ -29,6 +29,7 @@ Requires-Dist: pydantic>=2.13.4
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=15.0.0
 Requires-Dist: structlog>=25.5.0
+Requires-Dist: tree-sitter-go>=0.25.0
 Requires-Dist: tree-sitter-python>=0.25.0
 Requires-Dist: tree-sitter-typescript>=0.23.2
 Requires-Dist: tree-sitter>=0.25.2
@@ -60,7 +61,7 @@ Description-Content-Type: text/markdown
 
 CGIS parses a repository with tree-sitter into a graph of fully qualified symbols and the calls, imports and containment between them, stores it in SQLite, and serves it to AI agents over MCP. An agent that would otherwise grep and read whole files asks the graph instead.
 
-- **Languages:** Python · TypeScript / TSX
+- **Languages:** Python · TypeScript / TSX · Go (pilot)
 - **Runs:** locally — no account, no telemetry; the graph never leaves your disk ([the one opt-in exception](https://github.com/zaebee/codegraph-brain/blob/main/PRIVACY.md))
 
 ```console

{codegraph_brain-0.29.0 → codegraph_brain-0.31.0}/README.md

@@ -10,7 +10,7 @@
 
 CGIS parses a repository with tree-sitter into a graph of fully qualified symbols and the calls, imports and containment between them, stores it in SQLite, and serves it to AI agents over MCP. An agent that would otherwise grep and read whole files asks the graph instead.
 
-- **Languages:** Python · TypeScript / TSX
+- **Languages:** Python · TypeScript / TSX · Go (pilot)
 - **Runs:** locally — no account, no telemetry; the graph never leaves your disk ([the one opt-in exception](https://github.com/zaebee/codegraph-brain/blob/main/PRIVACY.md))
 
 ```console

codegraph_brain-0.31.0/benchmarks/agent_ab/analysis/exp1_gates.py

@@ -0,0 +1,88 @@
+"""Exp1 gates, exactly as pre-registered (docs/lab-notes/2026-10-15-exp1-radius-indirection.md)."""
+import json
+import statistics as st
+import sys
+from collections import defaultdict
+
+results, drift_path = sys.argv[1], sys.argv[2]
+rows = [json.loads(l) for l in open(results)]
+drift = json.load(open(drift_path))
+by = defaultdict(list)
+for r in rows:
+    by[r["task"]].append(r)
+
+billing_note = f"runs {len(rows)}, failed {sum(1 for r in rows if r.get('is_error') or r.get('subtype') != 'success')}, total ${sum(r.get('cost_usd') or 0 for r in rows):.2f}"
+print(billing_note)
+
+tasks = {}
+for t, rs in by.items():
+    cell = t.split("owner-exp1-")[1].split("-")[:2]
+    tasks[t] = {
+        "row": cell[0], "ind": cell[1] == "ind",
+        "cost": st.median(r["cost_usd"] for r in rs),
+        "recall": st.median(r["recall"] for r in rs),
+        "precision": st.median(r["precision"] for r in rs),
+        "calls": st.median(r["total_tool_calls"] for r in rs),
+        "n": len(rs), **drift[t],
+    }
+
+print(f"\n{'task':52} {'cost':>6} {'recall':>6} {'prec':>5} {'calls':>5} {'files':>5} {'drift':>5}")
+for t, v in sorted(tasks.items(), key=lambda kv: (kv[1]["row"], kv[1]["ind"], kv[1]["cost"])):
+    print(f"{t:52} {v['cost']:6.3f} {v['recall']:6.2f} {v['precision']:5.2f} {v['calls']:5.1f} {v['files']:5} {v['drift']:5.3f}")
+
+
+def med(sel, key="cost"):
+    xs = [v[key] for v in tasks.values() if sel(v)]
+    return (st.median(xs), len(xs)) if xs else (float("nan"), 0)
+
+
+print("\ncell medians (cost, recall):")
+for row in ("big", "small"):
+    for ind in (False, True):
+        c, n = med(lambda v: v["row"] == row and v["ind"] == ind)
+        r, _ = med(lambda v: v["row"] == row and v["ind"] == ind, "recall")
+        print(f"  {row:5} {'indirect' if ind else 'direct  '} n={n:2} cost {c:.3f} recall {r:.2f}")
+
+big, nb = med(lambda v: v["row"] == "big")
+small, ns = med(lambda v: v["row"] == "small")
+print(f"\nG1 radius: big {big:.3f} (n={nb}) / small {small:.3f} (n={ns}) = x{big / small:.2f} -> {'PASS' if big >= 1.5 * small else 'FAIL'} (>= x1.5)")
+
+print("G2 indirection (descriptive; big x direct n=2):")
+for row in ("big", "small"):
+    d, nd = med(lambda v: v["row"] == row and not v["ind"])
+    i, ni = med(lambda v: v["row"] == row and v["ind"])
+    rd, _ = med(lambda v: v["row"] == row and not v["ind"], "recall")
+    ri, _ = med(lambda v: v["row"] == row and v["ind"], "recall")
+    print(f"  {row}: indirect/direct cost x{i / d:.2f} (n {ni}/{nd}), recall drop {rd - ri:+.2f}")
+
+
+def ranks(xs):
+    order = sorted(range(len(xs)), key=lambda i: xs[i])
+    r = [0.0] * len(xs)
+    i = 0
+    while i < len(order):
+        j = i
+        while j + 1 < len(order) and xs[order[j + 1]] == xs[order[i]]:
+            j += 1
+        for k in range(i, j + 1):
+            r[order[k]] = (i + j) / 2 + 1
+        i = j + 1
+    return r
+
+
+def pearson(a, b):
+    ma, mb = st.mean(a), st.mean(b)
+    num = sum((x - ma) * (y - mb) for x, y in zip(a, b))
+    den = (sum((x - ma) ** 2 for x in a) * sum((y - mb) ** 2 for y in b)) ** 0.5
+    return num / den
+
+
+vs = list(tasks.values())
+c, d, f = ranks([v["cost"] for v in vs]), ranks([v["drift"] for v in vs]), ranks([v["files"] for v in vs])
+rcd, rcf, rdf = pearson(c, d), pearson(c, f), pearson(d, f)
+partial = (rcd - rcf * rdf) / ((1 - rcf**2) * (1 - rdf**2)) ** 0.5
+verdict = "PASS (drift adds nothing)" if abs(partial) < 0.2 else ("FAIL: drift matters, H1 refuted" if abs(partial) >= 0.3 else "INCONCLUSIVE")
+print(f"\nG3 Spearman: cost~files {rcf:+.2f}, cost~drift {rcd:+.2f}, drift~files {rdf:+.2f}; partial cost~drift|files {partial:+.2f} -> {verdict}")
+allr = [r["recall"] for r in rows]
+print(f"G4 ceiling: recall 1.00 in {sum(x >= 0.999 for x in allr)}/{len(allr)} runs; min {min(allr):.2f}; "
+      f"{'every cell at 1.00 -> cost-only' if all(v['recall'] >= 0.999 for v in vs) else 'not every task at 1.00'}")

codegraph_brain-0.31.0/benchmarks/agent_ab/analysis/exp2_gates.py

@@ -0,0 +1,54 @@
+"""Exp2 gates as pre-registered (paired). Usage: gates2.py results.jsonl pairs.json"""
+import json, math, random, statistics as st, sys
+from collections import defaultdict
+
+rows = [json.loads(l) for l in open(sys.argv[1])]
+pairs = json.load(open(sys.argv[2]))["pairs"]
+by = defaultdict(list)
+for r in rows:
+    by[r["task"]].append(r)
+print(f"runs {len(rows)}, errors {sum(1 for r in rows if r.get('is_error') or r.get('subtype') != 'success')}, "
+      f"contaminated {sum(r['contaminated'] for r in rows)}, total ${sum(r['cost_usd'] or 0 for r in rows):.2f}")
+
+
+def tid(fqn, cell):
+    return f"cgis-exp2-{cell}-" + fqn.rsplit(".", 1)[-1].strip("_").replace("_", "-")
+
+
+def med(t, k):
+    return st.median(r[k] for r in by[t])
+
+
+P = []
+for n, (d, fd, sd, i, fi, si) in enumerate(pairs, 1):
+    td, ti = tid(d, "dir"), tid(i, "ind")
+    P.append({"n": n, "d": td, "i": ti, "ratio": med(ti, "cost_usd") / med(td, "cost_usd"),
+              "drec": med(td, "recall") - med(ti, "recall"),
+              "cd": med(td, "cost_usd"), "ci": med(ti, "cost_usd"), "rd": med(td, "recall"), "ri": med(ti, "recall")})
+print(f"\n{'#':>2} {'direct':38} {'cost':>6} {'rec':>5} | {'indirect':38} {'cost':>6} {'rec':>5} | ratio  Δrec")
+for p in P:
+    print(f"{p['n']:>2} {p['d'][10:]:38} {p['cd']:6.3f} {p['rd']:5.2f} | {p['i'][10:]:38} {p['ci']:6.3f} {p['ri']:5.2f} | {p['ratio']:5.2f} {p['drec']:+.2f}")
+
+
+def gate(ps, label):
+    ratios = [p["ratio"] for p in ps]
+    mr = st.median(ratios)
+    wins = sum(r > 1 for r in ratios)
+    need = math.ceil(0.75 * len(ps))
+    v = "PASS" if mr >= 1.3 and wins >= need else ("REFUTED (≤1.1)" if mr <= 1.1 else "INCONCLUSIVE")
+    rnd = random.Random(0)
+    boots = sorted(st.median(rnd.choice(ratios) for _ in ratios) for _ in range(10000))
+    lo, hi = boots[250], boots[9749]
+    md = st.median(p["drec"] for p in ps)
+    print(f"\n[{label}] n={len(ps)}  G1 cost: median ratio {mr:.2f} (95% CI {lo:.2f}–{hi:.2f}), indirect dearer in {wins}/{len(ps)} (need {need}) -> {v}")
+    print(f"[{label}]       G2 recall: median Δ(direct−indirect) {md:+.2f} -> {'PASS' if md >= 0.10 else 'not met'}")
+
+
+gate(P, "all pairs")
+gate([p for p in P if p["n"] != 3], "without pair 3")
+allr = [r["recall"] for r in rows if "-desc-" not in r["task"]]
+print(f"\nG4 ceiling: per run {sum(x >= 0.999 for x in allr)}/{len(allr)} paired runs at 1.00 (min {min(allr):.2f}); "
+      f"per pair-task median: {sum(1 for p in P for x in (p['rd'], p['ri']) if x >= 0.999)}/{2 * len(P)} at 1.00")
+print("\nDescriptive (unpaired, dynamic hops):")
+for t in sorted(t for t in by if "-desc-" in t):
+    print(f"  {t[10:]:36} cost {med(t, 'cost_usd'):.3f} recall {med(t, 'recall'):.2f} precision {med(t, 'precision'):.2f}")

codegraph_brain-0.31.0/benchmarks/agent_ab/analysis/exp2_pairs.json

@@ -0,0 +1,71 @@
+{
+ "pairs": [
+  [
+   "cgis.guardian.metrics.reject_metrics_path",
+   3,
+   5,
+   "cgis.guardian.core.GuardianReviewer._finder_pass",
+   3,
+   5
+  ],
+  [
+   "cgis.languages.extractors",
+   4,
+   4,
+   "cgis.storage.sqlite_store.SQLiteStore.get_edge_stats",
+   5,
+   6
+  ],
+  [
+   "cgis.query.drift.fractal.build_ladder",
+   4,
+   6,
+   "cgis.guardian.core._sanitize_finder_result",
+   4,
+   10
+  ],
+  [
+   "cgis.query.fqn.resolve_fqn",
+   4,
+   13,
+   "cgis.query.render.metrics._as_terms",
+   4,
+   12
+  ],
+  [
+   "cgis.guardian.skeptic.visible_findings",
+   5,
+   6,
+   "cgis.storage.sqlite_store.SQLiteStore.get_incoming_edges",
+   5,
+   8
+  ],
+  [
+   "cgis.query.context.prompt._loc",
+   5,
+   10,
+   "cgis.query.drift.drift.DriftScorer.fit_templates",
+   6,
+   10
+  ],
+  [
+   "cgis.query.fqn.effective_prefix",
+   7,
+   15,
+   "cgis.query.drift.drift._fit_config",
+   6,
+   12
+  ]
+ ],
+ "unpaired": [
+  "cgis.guardian.render.render_finding",
+  "cgis.languages.go.naming._relative",
+  "cgis.languages.python._syntax.resolve_relative_module",
+  "cgis.languages.python._types.TypeResolver._first_top_level_arg",
+  "cgis.query.render.metrics._segment_exclusion",
+  "cgis.languages.python._annotations._collect",
+  "cgis.core.js_globals.specifier_fqn",
+  "cgis.guardian.providers.base.BaseProvider._record_usage",
+  "cgis.pipeline.refresh_dispatch"
+ ]
+}

codegraph_brain-0.31.0/benchmarks/agent_ab/analysis/exp2_post_review.py

@@ -0,0 +1,34 @@
+"""Exp2 post-review recompute (#634 review C1): pair 2 dropped, extractors rescored on corrected gold.
+
+Run from the repository root: uv run python benchmarks/agent_ab/analysis/exp2_post_review.py
+"""
+import json, random, statistics as st
+from pathlib import Path
+from cgis.bench.agent_task import load_tasks, score_answer
+from cgis.bench.transcript import parse_transcript
+
+tasks = {t.id: t for t in load_tasks(Path("benchmarks/agent_ab/tasks"))}
+rows = [json.loads(l) for l in open("benchmarks/agent_ab/results-exp2-full.jsonl")]
+for r in rows:
+    if r["task"].endswith("dir-extractors"):
+        tr = Path(r["transcript"])
+        if not tr.is_file():  # transcripts are git-ignored; a clean clone has only the stored scores
+            print(f"extractors run {r['run']}: transcript absent, stored precision {r['precision']:.2f}")
+            continue
+        s = score_answer(tasks[r["task"]], parse_transcript(tr.read_text().splitlines()).answer)
+        print(f"extractors run {r['run']}: recall {s.recall:.2f} precision {s.precision:.2f} (stored {r['precision']:.2f})")
+cost = {}
+for r in rows:
+    cost.setdefault(r["task"], []).append(r["cost_usd"])
+pairs = [("reject-metrics-path", "finder-pass"), ("build-ladder", "sanitize-finder-result"), ("resolve-fqn", "as-terms"),
+         ("visible-findings", "get-incoming-edges"), ("loc", "fit-templates"), ("effective-prefix", "fit-config")]
+rat = [st.median(cost["cgis-exp2-ind-" + i]) / st.median(cost["cgis-exp2-dir-" + d]) for d, i in pairs]
+rnd = random.Random(0)
+b = sorted(st.median(rnd.choice(rat) for _ in rat) for _ in range(10000))
+m = st.median(rat)
+v = "PASS" if m >= 1.3 and sum(x > 1 for x in rat) >= 5 else ("REFUTED" if m <= 1.1 else "INCONCLUSIVE")
+print(f"6 pairs: ratios {[round(x, 2) for x in rat]}, median {m:.3f}, 95% CI {b[250]:.2f}-{b[9749]:.2f}, dearer {sum(x > 1 for x in rat)}/6 -> {v}")
+gm = 1.0
+for x in rat:
+    gm *= x
+print(f"geometric mean {gm ** (1 / len(rat)):.3f}")

codegraph_brain-0.31.0/benchmarks/agent_ab/analysis/exp3_gates.py

@@ -0,0 +1,76 @@
+"""Exp3 gates as pre-registered. Usage: exp3_gates.py forced.jsonl (control is the stored exp1/exp2 full runs)."""
+import json, random, statistics as st, sys
+from collections import defaultdict
+
+FORCED = sys.argv[1]
+CONTROL = ["benchmarks/agent_ab/results-exp1-full.jsonl", "benchmarks/agent_ab/results-exp2-full.jsonl"]
+# Declared post-hoc gold corrections to stored control recall (lab notes exp1 C1, exp2 C1).
+RECALL_FIX = {("owner-exp1-big-ind-thread-for", 0): 1.0, ("owner-exp1-big-ind-thread-for", 1): 1.0,
+              ("owner-exp1-big-ind-thread-for", 2): 0.949}
+
+
+def load(paths, arm):
+    by = defaultdict(list)
+    for p in paths:
+        for line in open(p):
+            r = json.loads(line)
+            if r["arm"] != arm:
+                continue
+            r["recall"] = RECALL_FIX.get((r["task"], r["run"]), r["recall"]) if arm == "control" else r["recall"]
+            by[r["task"]].append(r)
+    return by
+
+
+ctl, frc = load(CONTROL, "control"), load([FORCED], "cgis-forced")
+rows = [r for rs in frc.values() for r in rs]
+print(f"forced runs {len(rows)}, errors {sum(1 for r in rows if r.get('is_error') or r.get('subtype') != 'success')}, "
+      f"contaminated {sum(r['contaminated'] for r in rows)}, cost ${sum(r['cost_usd'] or 0 for r in rows):.2f}, "
+      f"sessions with 0 cgis calls {sum(1 for r in rows if not r.get('cgis_calls'))}")
+
+
+def med(rs, k):
+    return st.median(r[k] for r in rs)
+
+
+def is_primary(t):
+    return t.startswith("owner-exp1-big-ind-") or t.startswith("cgis-exp2-desc-")
+
+
+T = {}
+for t in sorted(set(ctl) & set(frc)):
+    T[t] = {"ratio": med(frc[t], "cost_usd") / med(ctl[t], "cost_usd"),
+            "drec": med(frc[t], "recall") - med(ctl[t], "recall"),
+            "pc": med(ctl[t], "precision"), "pf": med(frc[t], "precision"),
+            "cc": med(ctl[t], "cost_usd"), "cf": med(frc[t], "cost_usd"),
+            "calls": med(frc[t], "cgis_calls"), "turns_c": med(ctl[t], "turns"), "turns_f": med(frc[t], "turns")}
+missing = sorted(set(ctl) ^ set(frc))
+if missing:
+    print("tasks not in both arms:", missing)
+print(f"\n{'task':52} {'ctl$':>6} {'cgis$':>6} {'ratio':>5} {'Δrec':>6} {'P ctl':>5} {'P cgis':>6} {'calls':>5}")
+for t, v in T.items():
+    print(f"{'*' if is_primary(t) else ' '}{t:51} {v['cc']:6.3f} {v['cf']:6.3f} {v['ratio']:5.2f} {v['drec']:+6.2f} {v['pc']:5.2f} {v['pf']:6.2f} {v['calls']:5.1f}")
+
+prim = [v for t, v in T.items() if is_primary(t)]
+r = [v["ratio"] for v in prim]
+mr, md = st.median(r), st.median(v["drec"] for v in prim)
+rnd = random.Random(0)
+b = sorted(st.median(rnd.choice(r) for _ in r) for _ in range(10000))
+helps = mr <= 0.80 and md >= -0.02
+print(f"\nPRIMARY (n={len(prim)}): median cost ratio {mr:.3f} (95% CI {b[250]:.2f}-{b[9749]:.2f}), "
+      f"median Δrecall {md:+.3f} -> {'HELPS (keep positioning)' if helps else 'DOES NOT HELP (kill agent-context positioning)'}")
+print(f"PRIMARY precision: control {st.median(v['pc'] for v in prim):.2f}, cgis-forced {st.median(v['pf'] for v in prim):.2f}")
+
+
+def cell(t):
+    p = t.split("-")
+    return "-".join(p[:4]) if t.startswith("owner-exp1") else "-".join(p[:3])
+
+
+groups = defaultdict(list)
+for t, v in T.items():
+    groups[cell(t)].append(v)
+print("\nSECONDARY by cell:")
+for g, vs in sorted(groups.items()):
+    print(f"  {g:24} n={len(vs):2} median ratio {st.median(v['ratio'] for v in vs):.2f}  Δrecall {st.median(v['drec'] for v in vs):+.2f}")
+allr = [v["ratio"] for v in T.values()]
+print(f"  ALL n={len(allr)} median ratio {st.median(allr):.2f}")