fix: move gitnexus-shared to devDependencies, use tsc for prepare

gitnexus-shared must remain available for tsc to resolve imports during
development/CI, but is not needed at runtime since it's bundled into
dist/_shared/. Moving it to devDependencies keeps it out of production
installs while allowing compilation. The prepare script now runs plain
tsc (no shared bundling needed for local dev).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

.cursor/index.mdc

@@ -0,0 +1,21 @@
+---
+alwaysApply: true
+---
+
+# GitNexus — Cursor project rules
+
+Last reviewed: 2026-03-24
+
+Canonical agent instructions: **[AGENTS.md](../AGENTS.md)** (GitNexus MCP rules, monorepo commands, Cursor Cloud notes). **[CLAUDE.md](../CLAUDE.md)** adds Claude Code-specific notes and points back to AGENTS.md for GitNexus.
+
+## Non-negotiables (always apply)
+
+- NEVER edit a function/class/method without running `gitnexus_impact` first.
+- NEVER rename symbols with find-and-replace — use `gitnexus_rename`.
+- NEVER commit without running `gitnexus_detect_changes()`.
+- NEVER ignore HIGH/CRITICAL risk warnings from impact analysis.
+- NEVER run `npx gitnexus analyze` without `--embeddings` if `.gitnexus/meta.json` shows stored embeddings.
+
+Full rules: **[AGENTS.md](../AGENTS.md)** (`gitnexus:start` block, Cursor Cloud section).
+
+**Rule architecture:** Prefer this file plus optional `.cursor/rules/*.mdc` globs (YAML `globs` in frontmatter). Legacy `.cursorrules` is deprecated; content lives here.

.cursor/rules/100-monorepo.mdc

@@ -0,0 +1,12 @@
+---
+globs:
+  - "gitnexus/**"
+  - "gitnexus-web/**"
+---
+
+# GitNexus build/test quick refs
+
+- CLI (`gitnexus/`): `npm test`; `npm run test:integration`; `npx tsc --noEmit`.
+- Web (`gitnexus-web/`): `npm test`; `npm run dev`; `npx tsc -b --noEmit`; `E2E=1 npx playwright test` (needs servers).
+- `npm install` in `gitnexus/` runs `prepare` (tsc build) and `postinstall` (tree-sitter patches); needs `python3`, `make`, `g++`.
+- LadybugDB locking tests may fail in containerized environments because of `/tmp` file locks (known issue, not a code bug).

.cursor/rules/200-eval.mdc

@@ -0,0 +1,14 @@
+---
+globs:
+  - "eval/**"
+---
+
+# GitNexus eval harness (Python)
+
+- **Run tests**: `cd eval && uv run pytest tests/`
+- **Run with coverage**: `cd eval && uv run coverage run -m pytest tests/ && uv run coverage report`
+- **Lint**: `cd eval && uv run ruff check .`
+- **Run eval**: `cd eval && uv run python run_eval.py --config configs/<config>.yaml`
+- Shared constants live in `eval/constants.py`; tool specs in `eval/tool_registry.py`.
+- Error logging uses `utils/errors.py` — set `GITNEXUS_EVAL_DEBUG=1` for full tracebacks.
+- Property-based tests use Hypothesis (`eval/tests/test_property_based.py`).

.cursorrules

@@ -1,5 +1,5 @@
-# AI Agent Rules
+# Deprecated for Cursor Agent Mode
 
-Follow .gitnexus/RULES.md for all project context and coding guidelines.
+Use **`.cursor/index.mdc`** (`alwaysApply: true`) for project rules. See [AGENTS.md](AGENTS.md).
 
-This project uses GitNexus MCP for code intelligence. See .gitnexus/RULES.md for available tools and best practices.
+This file is kept only as a breadcrumb for older workflows.

.git-blame-ignore-revs

@@ -0,0 +1,5 @@
+# Prettier initial formatting (2026-03-28)
+afcc3d1523f99c77ff67c4fd1af12334660113f6
+
+# ESLint unused import removal (2026-03-28)
+1491826bc8da5436d3b1eb092d9274f2c9f028a7

.gitattributes

@@ -0,0 +1,2 @@
+* text=auto eol=lf
+.husky/* text eol=lf

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,86 @@
+name: Bug report
+description: Report unexpected behavior or a regression
+labels: [bug]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        **Goal:** capture enough context to reproduce and fix the issue quickly.
+        Use **one issue per bug**; split unrelated problems.
+
+  - type: dropdown
+    id: area
+    attributes:
+      label: Area
+      description: Where does the problem show up?
+      options:
+        - gitnexus (CLI / core / indexing / MCP server)
+        - gitnexus-web (browser UI / WASM / workers)
+        - CI / GitHub Actions
+        - Documentation / developer experience
+        - Other
+    validations:
+      required: true
+
+  - type: textarea
+    id: summary
+    attributes:
+      label: Summary
+      description: One sentence — what went wrong?
+    validations:
+      required: true
+
+  - type: textarea
+    id: context
+    attributes:
+      label: Context
+      description: What were you trying to do? Any relevant links, PRs, or commits?
+    validations:
+      required: false
+
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected behavior
+    validations:
+      required: true
+
+  - type: textarea
+    id: actual
+    attributes:
+      label: Actual behavior
+    validations:
+      required: true
+
+  - type: textarea
+    id: reproduce
+    attributes:
+      label: Steps to reproduce
+      description: Ordered steps, sample repo or minimal case, commands run.
+      placeholder: |
+        1. …
+        2. …
+        3. …
+    validations:
+      required: true
+
+  - type: textarea
+    id: environment
+    attributes:
+      label: Environment
+      description: OS, Node version, browser (if web), GitNexus version or commit SHA.
+      placeholder: |
+        - OS:
+        - Node:
+        - Browser (if applicable):
+        - Commit / version:
+    validations:
+      required: false
+
+  - type: textarea
+    id: logs
+    attributes:
+      label: Logs / screenshots
+      description: Paste errors, stack traces, or attach screenshots (redact secrets).
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: true

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,74 @@
+name: Feature request
+description: Propose a new capability or improvement
+labels: [enhancement]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        **Goal:** describe the problem and desired outcome so maintainers can size and prioritize.
+        Prefer **small, shippable** requests; split large ideas into phases.
+
+  - type: dropdown
+    id: area
+    attributes:
+      label: Area
+      description: Primary part of the monorepo this relates to.
+      options:
+        - gitnexus (CLI / core / indexing / MCP server)
+        - gitnexus-web (browser UI / WASM / workers)
+        - CI / release / packaging
+        - Documentation / developer experience
+        - Other
+    validations:
+      required: true
+
+  - type: textarea
+    id: problem
+    attributes:
+      label: Problem or opportunity
+      description: What pain point or gap exists today?
+    validations:
+      required: true
+
+  - type: textarea
+    id: proposal
+    attributes:
+      label: Proposed solution
+      description: What should happen instead? User-visible behavior, APIs, or UX.
+    validations:
+      required: true
+
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: Alternatives considered
+      description: Other approaches you considered and why this one is preferred.
+    validations:
+      required: false
+
+  - type: textarea
+    id: acceptance
+    attributes:
+      label: Acceptance criteria
+      description: Testable conditions for “done” (bullets or checkboxes in prose).
+      placeholder: |
+        - When … then …
+        - Documentation / tests updated where appropriate
+    validations:
+      required: false
+
+  - type: textarea
+    id: constraints
+    attributes:
+      label: Constraints
+      description: Compatibility, performance, security, or “must not change” boundaries.
+    validations:
+      required: false
+
+  - type: checkboxes
+    id: willing
+    attributes:
+      label: Contribution
+      options:
+        - label: I am willing to open a PR for this (may need design discussion first).
+          required: false

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,52 @@
+## Summary
+
+<!-- One or two sentences: what does this PR change? -->
+
+## Motivation / context
+
+<!-- Why is this change needed? Link issues, ADRs, or prior discussion. -->
+
+## Areas touched
+
+<!-- Check all that apply -->
+
+- [ ] `gitnexus/` (CLI / core / MCP server)
+- [ ] `gitnexus-web/` (Vite / React UI)
+- [ ] `.github/` (workflows, actions)
+- [ ] `eval/` or other tooling
+- [ ] Docs / agent config only (`AGENTS.md`, `CLAUDE.md`, `.cursor/`, `llms.txt`, etc.)
+
+## Scope & constraints
+
+**In scope**
+
+- <!-- bullets -->
+
+**Explicitly out of scope / not done here**
+
+- <!-- bullets — prevents reviewers assuming missing work is an oversight -->
+
+## Implementation notes
+
+<!-- Optional: design choices, tradeoffs, follow-ups -->
+
+## Testing & verification
+
+<!-- What you ran; paste commands. Omit sections that do not apply. -->
+
+- [ ] `cd gitnexus && npm test`
+- [ ] `cd gitnexus && npm run test:integration` *(if core/indexing/MCP paths changed)*
+- [ ] `cd gitnexus && npx tsc --noEmit`
+- [ ] `cd gitnexus-web && npm test` *(if web changed)*
+- [ ] `cd gitnexus-web && npx tsc -b --noEmit` *(if web changed)*
+- [ ] Manual / Playwright E2E *(note environment — see `gitnexus-web/e2e/`)*
+
+## Risk & rollout
+
+<!-- Breaking changes, migrations, index refresh (`npx gitnexus analyze`), release notes -->
+
+## Checklist
+
+- [ ] PR body meets repo minimum length (workflow may label short descriptions)
+- [ ] If `AGENTS.md` / overlays changed: headers, scope block, and changelog updated per project conventions
+- [ ] No secrets, tokens, or machine-specific paths committed

.github/actions/setup-gitnexus-web/action.yml

@@ -0,0 +1,21 @@
+name: Setup GitNexus Web
+description: Setup Node.js 20, build gitnexus-shared, install web dependencies
+
+runs:
+  using: composite
+  steps:
+    - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+      with:
+        node-version: 20
+        cache: npm
+        cache-dependency-path: gitnexus-web/package-lock.json
+
+    - name: Build gitnexus-shared
+      run: npm install && npm run build
+      shell: bash
+      working-directory: gitnexus-shared
+
+    - name: Install web dependencies
+      run: npm ci
+      shell: bash
+      working-directory: gitnexus-web

.github/actions/setup-gitnexus/action.yml

@@ -16,6 +16,11 @@ runs:
         cache: npm
         cache-dependency-path: gitnexus/package-lock.json
 
+    - name: Build gitnexus-shared
+      run: npm install && npm run build
+      shell: bash
+      working-directory: gitnexus-shared
+
     - name: Install dependencies
       run: npm ci
       shell: bash

.github/release.yml

@@ -35,7 +35,7 @@ changelog:
         - dependencies
     - title: "\U0001F4DD Other Changes"
       labels:
-        - "*"
+        - '*'
       exclude:
         labels:
           - dependencies

.github/scripts/triage/embedding_utils.py

@@ -0,0 +1,257 @@
+"""Pure math utilities for triage sweep embedding analysis.
+
+All functions are stateless and perform no I/O (except model loading by FastEmbed).
+Each function operates on numpy arrays and returns numpy arrays or plain Python types.
+"""
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import NDArray
+from fastembed import TextEmbedding
+from sklearn.decomposition import PCA
+from sklearn.covariance import EllipticEnvelope
+from sklearn.metrics.pairwise import cosine_similarity
+
+# FastEmbed model — BAAI/bge-small-en-v1.5 produces 384-dimensional embeddings.
+# ~46MB quantized ONNX, runs on CPU in ~0.5s per batch of 32.
+EMBEDDING_MODEL: str = "BAAI/bge-small-en-v1.5"
+
+# Embedding dimensionality (determined by model choice).
+EMBEDDING_DIM: int = 384
+
+# Batch size for FastEmbed. 32 balances memory and throughput on
+# a 2-vCPU GitHub Actions runner with ~7GB RAM.
+EMBEDDING_BATCH_SIZE: int = 32
+
+
+def embed_texts(texts: list[str]) -> NDArray[np.float32]:
+    """Embed a list of texts into dense vectors using FastEmbed.
+
+    Returns an array of shape (len(texts), 384) with dtype float32.
+    Empty input returns a (0, 384) array.
+    """
+    if not texts:
+        return np.empty((0, EMBEDDING_DIM), dtype=np.float32)
+
+    model = TextEmbedding(model_name=EMBEDDING_MODEL)
+    vectors = list(model.embed(texts, batch_size=EMBEDDING_BATCH_SIZE))
+    return np.vstack(vectors).astype(np.float32)
+
+
+def normalize_rows(matrix: NDArray[np.float32]) -> NDArray[np.float32]:
+    """L2-normalize each row to unit length.
+
+    Zero-norm rows (e.g. from empty text) remain zero vectors.
+    Uses eps=1e-10 in the denominator to avoid division by zero.
+    """
+    if matrix.shape[0] == 0:
+        return matrix
+
+    norms = np.linalg.norm(matrix, axis=1, keepdims=True)
+    return matrix / (norms + 1e-10)
+
+
+def reduce_dimensions(
+    matrix: NDArray[np.float32],
+    max_components: int,
+) -> NDArray[np.float32]:
+    """Reduce dimensionality via PCA.
+
+    Computes n_components = min(max_components, n-1, d). If n_components < 1,
+    returns the matrix unchanged. Logs explained variance for observability.
+    """
+    n, d = matrix.shape
+    if n <= 1:
+        return matrix
+
+    n_components = min(max_components, n - 1, d)
+    if n_components < 1:
+        return matrix
+
+    pca = PCA(n_components=n_components)
+    reduced = pca.fit_transform(matrix)
+    explained = pca.explained_variance_ratio_.sum()
+    print(f"PCA: {d}d -> {n_components}d, explained variance: {explained:.3f}")
+    return reduced.astype(np.float32)
+
+
+def detect_outliers(
+    matrix: NDArray[np.float32],
+    contamination: float = 0.1,
+    iqr_multiplier: float = 3.0,
+    max_outlier_pct: float = 0.05,
+) -> list[tuple[int, float]]:
+    """Flag items whose Mahalanobis distance exceeds an IQR-based cutoff.
+
+    Uses EllipticEnvelope (robust covariance via MCD) to estimate the
+    multivariate Gaussian, then computes sqrt(squared Mahalanobis distance)
+    for each sample. The cutoff is Q75 + iqr_multiplier * IQR, which
+    adapts to the actual distribution of distances.
+
+    A hard cap ensures no more than max_outlier_pct * n items are flagged;
+    when the cap is hit, only the most extreme items (sorted by distance
+    descending) are kept.
+
+    Returns (index, distance) tuples sorted by index ascending, along with
+    the cutoff value stored as an attribute on the returned list.
+    """
+    n = matrix.shape[0]
+    if n < 2:
+        return []
+
+    envelope = EllipticEnvelope(contamination=contamination, random_state=42)
+    envelope.fit(matrix)
+
+    # .mahalanobis() returns squared Mahalanobis distances
+    distances = np.sqrt(envelope.mahalanobis(matrix))
+
+    # IQR-based cutoff
+    q25, q75 = np.percentile(distances, [25, 75])
+    iqr = q75 - q25
+    cutoff = q75 + iqr_multiplier * iqr
+
+    outlier_mask = distances > cutoff
+    indices = np.where(outlier_mask)[0]
+
+    # Hard cap: keep at most max_outlier_pct * n items
+    max_count = max(1, int(max_outlier_pct * n))
+    if len(indices) > max_count:
+        # Sort by distance descending, take the most extreme
+        sorted_by_dist = sorted(indices, key=lambda i: distances[i], reverse=True)
+        indices = np.array(sorted_by_dist[:max_count])
+
+    # Sort by index ascending for stable output
+    indices = np.sort(indices)
+    result = [(int(idx), float(distances[idx])) for idx in indices]
+
+    # Attach cutoff as metadata so the report can use it
+    result = _OutlierResult(result)  # type: ignore[assignment]
+    result.cutoff = float(cutoff)  # type: ignore[attr-defined]
+    return result  # type: ignore[return-value]
+
+
+class _OutlierResult(list):
+    """A list subclass that carries metadata (cutoff) from outlier detection."""
+    cutoff: float = 0.0
+
+
+def find_duplicate_pairs(
+    matrix: NDArray[np.float32],
+    threshold: float,
+) -> list[tuple[int, int, float]]:
+    """Find pairs of items with cosine similarity above threshold.
+
+    Returns (i, j, similarity) tuples where i < j. The input should be
+    L2-normalized embeddings (full dimensionality, not PCA-reduced) so
+    cosine similarity equals the dot product.
+    """
+    n = matrix.shape[0]
+    if n <= 1:
+        return []
+
+    sim_matrix = cosine_similarity(matrix)
+    # Upper triangle indices (i < j), excluding diagonal
+    rows, cols = np.triu_indices(n, k=1)
+    similarities = sim_matrix[rows, cols]
+
+    mask = similarities > threshold
+    pairs: list[tuple[int, int, float]] = []
+    for idx in np.where(mask)[0]:
+        pairs.append((int(rows[idx]), int(cols[idx]), float(similarities[idx])))
+
+    return pairs
+
+
+# ── Label suggestion via z-score normalized embedding similarity ──────
+
+# Z-score threshold: a label must be this many standard deviations above
+# the column mean to be considered a match.
+LABEL_Z_THRESHOLD: float = 1.5
+
+# Margin gate: the top-1 label must beat the second-best by this many
+# z-score units to be accepted (subsequent labels don't need a margin).
+LABEL_Z_MARGIN: float = 0.5
+
+# Floor for per-column standard deviation to avoid division by near-zero.
+LABEL_Z_STD_FLOOR: float = 0.01
+
+# Minimum raw cosine similarity required even if z-score is high.
+# Prevents suggesting labels that are "relatively best" but still poor.
+MIN_RAW_SIMILARITY: float = 0.3
+
+# Maximum number of labels to suggest per item.
+MAX_LABELS_PER_ITEM: int = 3
+
+
+def suggest_labels(
+    item_embeddings: NDArray[np.float32],
+    label_embeddings: NDArray[np.float32],
+    label_names: list[str],
+    z_threshold: float = LABEL_Z_THRESHOLD,
+    z_margin: float = LABEL_Z_MARGIN,
+    std_floor: float = LABEL_Z_STD_FLOOR,
+    min_raw_sim: float = MIN_RAW_SIMILARITY,
+    max_per_item: int = MAX_LABELS_PER_ITEM,
+) -> list[list[tuple[str, float]]]:
+    """Suggest labels for each item using z-score normalized similarity.
+
+    1. Compute raw cosine similarity matrix (n items x m labels).
+    2. Column-wise z-score: for each label j, normalize across all items.
+    3. For each item, rank labels by z-score descending.
+    4. Accept a label only if z >= z_threshold AND raw_sim >= min_raw_sim.
+    5. Margin gate: the top-1 label must beat #2 by z_margin; subsequent
+       labels don't need a margin.
+    6. Cap at max_per_item.
+
+    Returns a list of length n, where each element is a list of
+    (label_name, raw_similarity) tuples. Empty list if nothing qualifies.
+    """
+    n = item_embeddings.shape[0]
+    m = label_embeddings.shape[0]
+    if n == 0 or m == 0:
+        return [[] for _ in range(n)]
+
+    # (n, m) raw similarity matrix
+    sim_matrix = cosine_similarity(item_embeddings, label_embeddings)
+
+    # Column-wise z-score normalization
+    col_means = sim_matrix.mean(axis=0)  # shape (m,)
+    col_stds = sim_matrix.std(axis=0)    # shape (m,)
+    col_stds = np.maximum(col_stds, std_floor)
+    z_matrix = (sim_matrix - col_means) / col_stds
+
+    suggestions: list[list[tuple[str, float]]] = []
+    for i in range(n):
+        z_row = z_matrix[i]
+        raw_row = sim_matrix[i]
+
+        # Rank labels by z-score descending
+        ranked = np.argsort(z_row)[::-1]
+
+        item_labels: list[tuple[str, float]] = []
+
+        # Margin gate: top-1 z-score must beat #2 by z_margin.
+        # If not, the assignment is ambiguous — skip this item entirely.
+        if len(ranked) > 1:
+            top1_z = float(z_row[ranked[0]])
+            top2_z = float(z_row[ranked[1]])
+            if top1_z - top2_z < z_margin:
+                suggestions.append(item_labels)
+                continue
+
+        for rank_pos, idx in enumerate(ranked):
+            if len(item_labels) >= max_per_item:
+                break
+
+            z_val = float(z_row[idx])
+            raw_val = float(raw_row[idx])
+
+            # Must pass both z-threshold and raw similarity floor
+            if z_val < z_threshold or raw_val < min_raw_sim:
+                continue
+
+            item_labels.append((label_names[idx], raw_val))
+
+        suggestions.append(item_labels)
+
+    return suggestions

.github/scripts/triage/requirements.txt

@@ -0,0 +1,4 @@
+fastembed>=0.5.0
+numpy>=1.26.0
+scikit-learn>=1.4.0
+scipy>=1.10.0

.github/scripts/triage/sweep.py

@@ -0,0 +1,600 @@
+"""Triage sweep: fetch open issues/PRs, detect outliers and duplicates, generate a report.
+
+Entrypoint script for the triage-sweep workflow. Fetches all open items via
+the GitHub REST API, delegates embedding and analysis to embedding_utils,
+generates a markdown report, and optionally creates a report issue.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+import urllib.request
+import urllib.parse
+from typing import TypedDict
+from datetime import datetime, timezone
+
+from embedding_utils import (
+    embed_texts,
+    normalize_rows,
+    reduce_dimensions,
+    detect_outliers,
+    find_duplicate_pairs,
+    suggest_labels,
+    LABEL_Z_THRESHOLD,
+    LABEL_Z_MARGIN,
+    LABEL_Z_STD_FLOOR,
+    MIN_RAW_SIMILARITY,
+    MAX_LABELS_PER_ITEM,
+)
+
+# ── Thresholds (overridable via workflow_dispatch inputs) ──────────────
+
+# IQR multiplier for outlier cutoff: cutoff = Q75 + IQR_MULTIPLIER * IQR.
+IQR_MULTIPLIER: float = float(os.environ.get("INPUT_IQR_MULTIPLIER", "3.0"))
+
+# Hard cap: at most this fraction of items can be flagged as outliers.
+MAX_OUTLIER_PCT: float = float(os.environ.get("INPUT_MAX_OUTLIER_PCT", "0.05"))
+
+# EllipticEnvelope contamination: expected fraction of outliers in the data.
+# Governs how aggressively the robust covariance downweights extreme points.
+CONTAMINATION: float = float(os.environ.get("INPUT_CONTAMINATION", "0.1"))
+
+# Cosine similarity above which two items are flagged as duplicates.
+# 0.92 catches near-identical issues while tolerating paraphrasing.
+COSINE_THRESHOLD: float = float(os.environ.get("INPUT_COSINE_THRESHOLD", "0.92"))
+
+# Hard cap on items to process. Prevents runaway costs on very large repos.
+MAX_ITEMS: int = int(os.environ.get("INPUT_MAX_ITEMS", "500"))
+
+# When true, print report to stdout/file but do not create a GitHub issue.
+DRY_RUN: bool = os.environ.get("INPUT_DRY_RUN", "false").lower() == "true"
+
+# ── Fixed constants (not user-configurable) ───────────────────────────
+
+# Minimum number of samples required for EllipticEnvelope to fit
+# a Gaussian reliably. Must be >= 3 * PCA_MAX_COMPONENTS so the
+# covariance matrix is estimated from enough data points.
+PCA_MAX_COMPONENTS: int = 20
+MIN_SAMPLES_FOR_OUTLIER_DETECTION: int = 100
+
+# Max character length for embedding input text. bge-small-en-v1.5 has a
+# 512-token context window (~4 chars/token). We keep title + body under
+# this limit so the model sees the full text instead of silently truncating.
+MAX_EMBED_CHARS: int = 2000
+
+# GitHub REST API page size (max allowed is 100).
+API_PAGE_SIZE: int = 100
+
+# Report issue label.
+REPORT_LABEL: str = "triage-report"
+
+# Report file path (written for the summary step to pick up).
+REPORT_FILE: str = "/tmp/triage-report.md"
+
+
+class TriageItem(TypedDict):
+    """One open issue or PR, with only the fields we need."""
+    number: int
+    title: str
+    html_url: str
+    is_pr: bool
+    labels: list[str]
+    created_at: str
+    # title + body concatenated, used as embedding input
+    text: str
+
+
+def github_api_get(path: str) -> list[dict]:
+    """Make a single authenticated GET request to the GitHub REST API.
+
+    Reads GITHUB_TOKEN and GITHUB_REPOSITORY from env. Raises SystemExit
+    with the HTTP status and response body on any non-2xx response.
+    """
+    token = os.environ["GITHUB_TOKEN"]
+    repo = os.environ["GITHUB_REPOSITORY"]
+    url = f"https://api.github.com/repos/{repo}{path}"
+
+    req = urllib.request.Request(url)
+    req.add_header("Accept", "application/vnd.github+json")
+    req.add_header("Authorization", f"Bearer {token}")
+    req.add_header("X-GitHub-Api-Version", "2022-11-28")
+
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        body = e.read().decode("utf-8", errors="replace")
+        print(f"::error::GitHub API {e.code}: {body}")
+        sys.exit(1)
+
+
+def fetch_all_open_items() -> list[TriageItem]:
+    """Paginate through all open issues and PRs.
+
+    Returns up to MAX_ITEMS TriageItem dicts. Items with a pull_request
+    key are marked is_pr=True. The text field is title + body concatenated.
+    """
+    items: list[TriageItem] = []
+    page = 1
+
+    while len(items) < MAX_ITEMS:
+        path = (
+            f"/issues?state=open&per_page={API_PAGE_SIZE}"
+            f"&sort=created&direction=desc&page={page}"
+        )
+        data = github_api_get(path)
+
+        if not data:
+            break
+
+        for raw in data:
+            if len(items) >= MAX_ITEMS:
+                break
+
+            body = raw.get("body", "") or ""
+            full_text = f"{raw['title']}\n\n{body}"
+            # Truncate to fit the embedding model's token window.
+            # Title is always preserved; body gets clipped if needed.
+            if len(full_text) > MAX_EMBED_CHARS:
+                full_text = full_text[:MAX_EMBED_CHARS]
+            items.append(TriageItem(
+                number=raw["number"],
+                title=raw["title"],
+                html_url=raw["html_url"],
+                is_pr="pull_request" in raw,
+                labels=[lbl["name"] for lbl in raw.get("labels", [])],
+                created_at=raw["created_at"],
+                text=full_text,
+            ))
+
+        if len(data) < API_PAGE_SIZE:
+            break
+
+        page += 1
+
+    return items
+
+
+class RepoLabel(TypedDict):
+    """A label from the repo with its embedding text."""
+    name: str
+    description: str
+    # "name: description" concatenated for embedding
+    text: str
+
+
+def fetch_repo_labels() -> list[RepoLabel]:
+    """Fetch all labels from the repository, paginating if needed.
+
+    Returns labels with name, description, and a text field suitable
+    for embedding ("name: description"). Labels with no description
+    use just the name.
+    """
+    labels: list[RepoLabel] = []
+    page = 1
+
+    while True:
+        data = github_api_get(f"/labels?per_page={API_PAGE_SIZE}&page={page}")
+        for raw in data:
+            name = raw["name"]
+            desc = raw.get("description", "") or ""
+            text = f"{name}: {desc}" if desc else name
+            labels.append(RepoLabel(name=name, description=desc, text=text))
+
+        if len(data) < API_PAGE_SIZE:
+            break
+        page += 1
+
+    return labels
+
+
+def apply_labels_to_item(item_number: int, labels: list[str]) -> None:
+    """Add labels to a single issue/PR via the GitHub API.
+
+    Skips silently if labels list is empty. Uses POST which adds labels
+    without removing existing ones.
+    """
+    if not labels:
+        return
+
+    token = os.environ["GITHUB_TOKEN"]
+    repo = os.environ["GITHUB_REPOSITORY"]
+    url = f"https://api.github.com/repos/{repo}/issues/{item_number}/labels"
+
+    payload = json.dumps({"labels": labels}).encode("utf-8")
+    req = urllib.request.Request(url, data=payload, method="POST")
+    req.add_header("Accept", "application/vnd.github+json")
+    req.add_header("Authorization", f"Bearer {token}")
+    req.add_header("X-GitHub-Api-Version", "2022-11-28")
+    req.add_header("Content-Type", "application/json")
+
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            resp.read()
+    except urllib.error.HTTPError as e:
+        body = e.read().decode("utf-8", errors="replace")
+        # Non-fatal: log warning but don't abort the sweep
+        print(f"::warning::Failed to label #{item_number}: {e.code} {body}")
+
+
+def _item_age(created_at: str) -> str:
+    """Compute a human-readable age string from an ISO 8601 created_at timestamp."""
+    try:
+        created = datetime.fromisoformat(created_at.replace("Z", "+00:00"))
+        delta = datetime.now(timezone.utc) - created
+        days = delta.days
+        if days < 1:
+            return "<1d"
+        if days < 30:
+            return f"{days}d"
+        if days < 365:
+            return f"{days // 30}mo"
+        return f"{days // 365}y"
+    except (ValueError, TypeError):
+        return "?"
+
+
+def _suggested_action(a: TriageItem, b: TriageItem) -> str:
+    """Determine a suggested action for a duplicate pair based on types and age."""
+    if a["is_pr"] and b["is_pr"]:
+        return "Review for overlap"
+    if not a["is_pr"] and not b["is_pr"]:
+        # Both issues — close the newer one
+        try:
+            a_dt = datetime.fromisoformat(a["created_at"].replace("Z", "+00:00"))
+            b_dt = datetime.fromisoformat(b["created_at"].replace("Z", "+00:00"))
+            newer = b if b_dt > a_dt else a
+        except (ValueError, TypeError):
+            newer = b
+        return f"Close #{newer['number']} as duplicate"
+    # One issue, one PR
+    return "Link PR to issue"
+
+
+def generate_report(
+    items: list[TriageItem],
+    outlier_results: list[tuple[int, float]],
+    duplicate_pairs: list[tuple[int, int, float]],
+    label_suggestions: list[list[tuple[str, float]]] | None = None,
+) -> str:
+    """Generate a structured markdown triage report."""
+    now = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+    repo = os.environ.get("GITHUB_REPOSITORY", "unknown/repo")
+
+    # Compute label suggestion counts early for the health table
+    outlier_set = {idx for idx, _ in outlier_results}
+    suggested_count = 0
+    if label_suggestions is not None:
+        suggested_count = sum(
+            1 for i, s in enumerate(label_suggestions)
+            if s and not items[i]["labels"] and i not in outlier_set
+        )
+
+    # ── Health summary table at the top ──────────────────────────────
+    lines: list[str] = [
+        "## Triage Sweep Report",
+        "",
+        f"**Run:** {now} UTC",
+        f"**Items analyzed:** {len(items)}",
+        f"**Thresholds:** IQR multiplier {IQR_MULTIPLIER}, Cosine > {COSINE_THRESHOLD}",
+        "",
+        "### Health Summary",
+        "",
+        "| Metric | Value |",
+        "|--------|-------|",
+        f"| Items analyzed | {len(items)} |",
+        f"| Outliers flagged | {len(outlier_results)} |",
+        f"| Duplicate pairs | {len(duplicate_pairs)} |",
+        f"| Label suggestions | {suggested_count} |",
+        "",
+    ]
+
+    # ── Outlier section ──────────────────────────────────────────────
+    # Determine cutoff for high-confidence split
+    cutoff = getattr(outlier_results, "cutoff", 0.0)
+    high_conf_cutoff = 2 * cutoff if cutoff > 0 else float("inf")
+
+    high_conf = [(idx, d) for idx, d in outlier_results if d > high_conf_cutoff]
+    borderline = [(idx, d) for idx, d in outlier_results if d <= high_conf_cutoff]
+
+    lines.extend([
+        f"### Potential Outliers / Spam ({len(outlier_results)})",
+        "",
+        "Items with unusually high Mahalanobis distance from the distribution center.",
+        "These may be spam, off-topic, or poorly described.",
+        "",
+    ])
+
+    if high_conf:
+        lines.append(f"**High Confidence** ({len(high_conf)} items, distance > 2x cutoff)")
+        lines.append("")
+        lines.append("| # | Type | Title | Distance | Age |")
+        lines.append("|---|------|-------|----------|-----|")
+        for idx, distance in high_conf:
+            item = items[idx]
+            kind = "PR" if item["is_pr"] else "Issue"
+            age = _item_age(item["created_at"])
+            title = item["title"][:80] + ("..." if len(item["title"]) > 80 else "")
+            lines.append(
+                f"| [#{item['number']}]({item['html_url']}) "
+                f"| {kind} | {title} | {distance:.2f} | {age} |"
+            )
+        lines.append("")
+
+    if borderline:
+        lines.append("<details>")
+        lines.append(f"<summary>Borderline ({len(borderline)} items)</summary>")
+        lines.append("")
+        lines.append("| # | Type | Title | Distance | Age |")
+        lines.append("|---|------|-------|----------|-----|")
+        for idx, distance in borderline:
+            item = items[idx]
+            kind = "PR" if item["is_pr"] else "Issue"
+            age = _item_age(item["created_at"])
+            title = item["title"][:80] + ("..." if len(item["title"]) > 80 else "")
+            lines.append(
+                f"| [#{item['number']}]({item['html_url']}) "
+                f"| {kind} | {title} | {distance:.2f} | {age} |"
+            )
+        lines.append("")
+        lines.append("</details>")
+        lines.append("")
+
+    if not outlier_results:
+        lines.append("None found.")
+
+    # ── Duplicate pairs section ──────────────────────────────────────
+    lines.extend([
+        "",
+        f"### Potential Duplicates ({len(duplicate_pairs)} pairs)",
+        "",
+        "Pairs of items with cosine similarity above the threshold.",
+        "",
+    ])
+
+    if duplicate_pairs:
+        lines.append("| Item A | Item B | Similarity | Suggested Action |")
+        lines.append("|--------|--------|------------|------------------|")
+        for i, j, sim in duplicate_pairs:
+            a = items[i]
+            b = items[j]
+            kind_a = "PR" if a["is_pr"] else "Issue"
+            kind_b = "PR" if b["is_pr"] else "Issue"
+            action = _suggested_action(a, b)
+            lines.append(
+                f"| [#{a['number']}]({a['html_url']}) {kind_a}: {a['title']} "
+                f"| [#{b['number']}]({b['html_url']}) {kind_b}: {b['title']} "
+                f"| {sim:.3f} | {action} |"
+            )
+    else:
+        lines.append("None found.")
+
+    # ── Label suggestions section ────────────────────────────────────
+    if label_suggestions is not None:
+        # High confidence: top-1 label with raw_sim >= 0.5
+        # Low confidence: top-1 label with raw_sim < 0.5
+        high_conf_labels: list[tuple[int, list[tuple[str, float]]]] = []
+        low_conf_labels: list[tuple[int, list[tuple[str, float]]]] = []
+        for i, sugs in enumerate(label_suggestions):
+            if sugs and not items[i]["labels"] and i not in outlier_set:
+                top1 = sugs[:1]
+                if top1[0][1] >= 0.5:
+                    high_conf_labels.append((i, top1))
+                else:
+                    low_conf_labels.append((i, top1))
+
+        total_suggestions = len(high_conf_labels) + len(low_conf_labels)
+        lines.extend([
+            "",
+            f"### Suggested Labels ({total_suggestions} unlabeled items)",
+            "",
+            "Labels suggested by z-score normalized embedding similarity against repo label descriptions.",
+            "Only shown for unlabeled items that were not flagged as outliers.",
+            "",
+        ])
+
+        # Label concentration warning
+        if total_suggestions > 0:
+            label_counts: dict[str, int] = {}
+            for _, sugs in high_conf_labels + low_conf_labels:
+                for name, _ in sugs:
+                    label_counts[name] = label_counts.get(name, 0) + 1
+            for name, count in label_counts.items():
+                if count > total_suggestions * 0.5:
+                    lines.append(
+                        f"> **Warning:** Label `{name}` accounts for "
+                        f"{count}/{total_suggestions} suggestions "
+                        f"({count * 100 // total_suggestions}%). "
+                        f"Consider reviewing label descriptions for specificity."
+                    )
+                    lines.append("")
+
+        if high_conf_labels:
+            lines.append("| # | Type | Title | Suggested Label |")
+            lines.append("|---|------|-------|--------------------|")
+            for idx, sugs in high_conf_labels:
+                item = items[idx]
+                kind = "PR" if item["is_pr"] else "Issue"
+                label_strs = [f"`{name}` ({score:.2f})" for name, score in sugs]
+                lines.append(
+                    f"| [#{item['number']}]({item['html_url']}) "
+                    f"| {kind} | {item['title']} | {', '.join(label_strs)} |"
+                )
+
+        if low_conf_labels:
+            lines.append("")
+            lines.append("<details>")
+            lines.append(f"<summary>Low-confidence suggestions ({len(low_conf_labels)} items)</summary>")
+            lines.append("")
+            lines.append("| # | Type | Title | Suggested Label |")
+            lines.append("|---|------|-------|--------------------|")
+            for idx, sugs in low_conf_labels:
+                item = items[idx]
+                kind = "PR" if item["is_pr"] else "Issue"
+                label_strs = [f"`{name}` ({score:.2f})" for name, score in sugs]
+                lines.append(
+                    f"| [#{item['number']}]({item['html_url']}) "
+                    f"| {kind} | {item['title']} | {', '.join(label_strs)} |"
+                )
+            lines.append("")
+            lines.append("</details>")
+
+        if not high_conf_labels and not low_conf_labels:
+            lines.append("No unlabeled items need suggestions.")
+
+    lines.extend([
+        "",
+        "### Summary",
+        "",
+        f"- {len(outlier_results)} outliers flagged for review",
+        f"- {len(duplicate_pairs)} duplicate pairs found",
+        f"- {len(items)} items analyzed in total",
+    ])
+
+    if label_suggestions is not None:
+        lines.append(f"- {suggested_count} items suggested for labeling")
+
+    lines.extend([
+        "",
+        "---",
+        f"*Generated by [triage-sweep](https://github.com/{repo}/actions) — no LLM was used.*",
+    ])
+
+    return "\n".join(lines)
+
+
+def create_report_issue(report_body: str) -> None:
+    """Create a GitHub issue with the triage report.
+
+    Posts to the issues API with the triage-report label.
+    Raises SystemExit on non-201 response.
+    """
+    token = os.environ["GITHUB_TOKEN"]
+    repo = os.environ["GITHUB_REPOSITORY"]
+    url = f"https://api.github.com/repos/{repo}/issues"
+
+    today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    payload = json.dumps({
+        "title": f"Triage Sweep Report — {today}",
+        "body": report_body,
+        "labels": [REPORT_LABEL],
+    }).encode("utf-8")
+
+    req = urllib.request.Request(url, data=payload, method="POST")
+    req.add_header("Accept", "application/vnd.github+json")
+    req.add_header("Authorization", f"Bearer {token}")
+    req.add_header("X-GitHub-Api-Version", "2022-11-28")
+    req.add_header("Content-Type", "application/json")
+
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            resp_body = resp.read().decode("utf-8")
+            if resp.status != 201:
+                print(f"::error::Failed to create issue: {resp.status} {resp_body}")
+                sys.exit(1)
+            result = json.loads(resp_body)
+            print(f"Created issue: {result.get('html_url', 'unknown')}")
+    except urllib.error.HTTPError as e:
+        body = e.read().decode("utf-8", errors="replace")
+        print(f"::error::Failed to create issue: {e.code} {body}")
+        sys.exit(1)
+
+
+def write_report(report: str) -> None:
+    """Write the report to the file system for the summary step."""
+    with open(REPORT_FILE, "w", encoding="utf-8") as f:
+        f.write(report)
+
+
+def main() -> None:
+    """Orchestrate the full triage sweep."""
+    # 1. Validate environment
+    for var in ("GITHUB_TOKEN", "GITHUB_REPOSITORY"):
+        if not os.environ.get(var):
+            print(f"::error::Missing required environment variable: {var}")
+            sys.exit(1)
+
+    # 2. Fetch all open issues + PRs
+    items = fetch_all_open_items()
+    print(f"Fetched {len(items)} open items")
+
+    if len(items) == 0:
+        report = "## Triage Sweep Report\n\nNo open issues or PRs found."
+        write_report(report)
+        print("No items to analyze.")
+        return
+
+    # 3. Extract texts for embedding
+    texts: list[str] = [item["text"] for item in items]
+
+    # 4. Embed all texts (returns numpy float32 array of shape [n, 384])
+    embeddings = embed_texts(texts)
+
+    # 5. L2-normalize
+    embeddings = normalize_rows(embeddings)
+
+    # 6. Outlier detection (Mahalanobis via EllipticEnvelope)
+    outlier_results: list[tuple[int, float]] = []
+    if len(items) >= MIN_SAMPLES_FOR_OUTLIER_DETECTION:
+        reduced = reduce_dimensions(embeddings, PCA_MAX_COMPONENTS)
+        outlier_results = detect_outliers(
+            reduced,
+            contamination=CONTAMINATION,
+            iqr_multiplier=IQR_MULTIPLIER,
+            max_outlier_pct=MAX_OUTLIER_PCT,
+        )
+    else:
+        print(
+            f"Skipping outlier detection: {len(items)} items < "
+            f"{MIN_SAMPLES_FOR_OUTLIER_DETECTION} minimum"
+        )
+
+    # 7. Duplicate detection (pairwise cosine similarity)
+    duplicate_pairs = find_duplicate_pairs(embeddings, COSINE_THRESHOLD)
+
+    # 8. Label suggestion via embedding similarity
+    label_suggestions: list[list[tuple[str, float]]] | None = None
+    repo_labels = fetch_repo_labels()
+    if repo_labels:
+        label_texts = [lbl["text"] for lbl in repo_labels]
+        label_names = [lbl["name"] for lbl in repo_labels]
+        label_embeddings = embed_texts(label_texts)
+        label_embeddings = normalize_rows(label_embeddings)
+        label_suggestions = suggest_labels(embeddings, label_embeddings, label_names)
+        print(f"Computed label suggestions against {len(repo_labels)} repo labels")
+
+        # NOTE: Auto-labeling is disabled. The report shows suggestions for
+        # human review. To re-enable, uncomment the block below.
+        #
+        # # Apply top label to unlabeled items (unless dry run)
+        # # Skip outliers — flagged items shouldn't get categorized
+        # outlier_set = {idx for idx, _ in outlier_results}
+        # if not DRY_RUN:
+        #     applied_count = 0
+        #     for i, sugs in enumerate(label_suggestions):
+        #         if sugs and not items[i]["labels"] and i not in outlier_set:
+        #             # Apply only the top-1 label (highest confidence)
+        #             apply_labels_to_item(items[i]["number"], [sugs[0][0]])
+        #             applied_count += 1
+        #     print(f"Applied labels to {applied_count} unlabeled items")
+    else:
+        print("No repo labels found — skipping label suggestions")
+
+    # 9. Generate report
+    report = generate_report(items, outlier_results, duplicate_pairs, label_suggestions)
+
+    # 10. Write report to file (for summary step)
+    write_report(report)
+
+    # 11. Create report issue (unless dry run)
+    if DRY_RUN:
+        print("Dry run — skipping issue creation and label application.")
+        print(report)
+    else:
+        create_report_issue(report)
+        print("Report issue created.")
+
+
+if __name__ == "__main__":
+    main()

.github/scripts/triage/test_embedding_utils.py

@@ -0,0 +1,468 @@
+"""Tests for embedding_utils.py — all embedding model calls are mocked."""
+from __future__ import annotations
+
+import sys
+from unittest.mock import patch, MagicMock
+import numpy as np
+import pytest
+
+# Mock fastembed before importing the module under test (persistent)
+if "fastembed" not in sys.modules:
+    sys.modules["fastembed"] = MagicMock()
+
+from embedding_utils import (
+    embed_texts,
+    normalize_rows,
+    reduce_dimensions,
+    detect_outliers,
+    find_duplicate_pairs,
+    suggest_labels,
+    EMBEDDING_DIM,
+    EMBEDDING_MODEL,
+    EMBEDDING_BATCH_SIZE,
+    LABEL_Z_THRESHOLD,
+    LABEL_Z_MARGIN,
+    LABEL_Z_STD_FLOOR,
+    MIN_RAW_SIMILARITY,
+    MAX_LABELS_PER_ITEM,
+)
+
+
+class TestEmbedTexts:
+    """Tests for the embed_texts function."""
+
+    def test_empty_list_returns_empty_array(self):
+        result = embed_texts([])
+        assert result.shape == (0, EMBEDDING_DIM)
+        assert result.dtype == np.float32
+
+    @patch("embedding_utils.TextEmbedding")
+    def test_single_text(self, mock_cls):
+        mock_model = MagicMock()
+        mock_cls.return_value = mock_model
+        vec = np.random.randn(EMBEDDING_DIM).astype(np.float32)
+        mock_model.embed.return_value = iter([vec])
+
+        result = embed_texts(["hello world"])
+
+        mock_cls.assert_called_once_with(model_name=EMBEDDING_MODEL)
+        mock_model.embed.assert_called_once_with(
+            ["hello world"], batch_size=EMBEDDING_BATCH_SIZE
+        )
+        assert result.shape == (1, EMBEDDING_DIM)
+        assert result.dtype == np.float32
+        np.testing.assert_array_almost_equal(result[0], vec)
+
+    @patch("embedding_utils.TextEmbedding")
+    def test_multiple_texts(self, mock_cls):
+        mock_model = MagicMock()
+        mock_cls.return_value = mock_model
+        vecs = [
+            np.random.randn(EMBEDDING_DIM).astype(np.float32)
+            for _ in range(5)
+        ]
+        mock_model.embed.return_value = iter(vecs)
+
+        result = embed_texts(["a", "b", "c", "d", "e"])
+        assert result.shape == (5, EMBEDDING_DIM)
+        assert result.dtype == np.float32
+
+
+class TestNormalizeRows:
+    """Tests for L2 row normalization."""
+
+    def test_empty_matrix(self):
+        m = np.empty((0, 10), dtype=np.float32)
+        result = normalize_rows(m)
+        assert result.shape == (0, 10)
+
+    def test_single_row(self):
+        m = np.array([[3.0, 4.0]], dtype=np.float32)
+        result = normalize_rows(m)
+        # Norm should be ~1.0
+        norm = np.linalg.norm(result[0])
+        assert abs(norm - 1.0) < 1e-5
+
+    def test_multiple_rows(self):
+        rng = np.random.default_rng(42)
+        m = rng.standard_normal((10, 50)).astype(np.float32)
+        result = normalize_rows(m)
+        norms = np.linalg.norm(result, axis=1)
+        np.testing.assert_allclose(norms, 1.0, atol=1e-5)
+
+    def test_zero_row_stays_near_zero(self):
+        m = np.array([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]], dtype=np.float32)
+        result = normalize_rows(m)
+        # Zero row divided by eps -> very small values
+        assert np.linalg.norm(result[0]) < 1e-3
+        # Non-zero row should be unit norm
+        assert abs(np.linalg.norm(result[1]) - 1.0) < 1e-5
+
+    def test_preserves_direction(self):
+        m = np.array([[2.0, 0.0], [0.0, 3.0]], dtype=np.float32)
+        result = normalize_rows(m)
+        np.testing.assert_allclose(result[0], [1.0, 0.0], atol=1e-5)
+        np.testing.assert_allclose(result[1], [0.0, 1.0], atol=1e-5)
+
+
+class TestReduceDimensions:
+    """Tests for PCA dimensionality reduction."""
+
+    def test_single_sample_returns_unchanged(self):
+        m = np.random.randn(1, 50).astype(np.float32)
+        result = reduce_dimensions(m, 10)
+        np.testing.assert_array_equal(result, m)
+
+    def test_reduces_dimensions(self):
+        rng = np.random.default_rng(42)
+        m = rng.standard_normal((100, 50)).astype(np.float32)
+        result = reduce_dimensions(m, 10)
+        assert result.shape == (100, 10)
+        assert result.dtype == np.float32
+
+    def test_caps_at_n_minus_1(self):
+        rng = np.random.default_rng(42)
+        # 5 samples, 20 features -> max components = 4 (n-1)
+        m = rng.standard_normal((5, 20)).astype(np.float32)
+        result = reduce_dimensions(m, 50)
+        assert result.shape == (5, 4)
+
+    def test_caps_at_d(self):
+        rng = np.random.default_rng(42)
+        # 100 samples, 3 features -> max components = 3
+        m = rng.standard_normal((100, 3)).astype(np.float32)
+        result = reduce_dimensions(m, 50)
+        assert result.shape == (100, 3)
+
+    def test_max_components_respected(self):
+        rng = np.random.default_rng(42)
+        m = rng.standard_normal((50, 30)).astype(np.float32)
+        result = reduce_dimensions(m, 5)
+        assert result.shape[1] == 5
+
+
+class TestDetectOutliers:
+    """Tests for IQR-based outlier detection."""
+
+    def test_single_sample_returns_empty(self):
+        m = np.random.randn(1, 5).astype(np.float32)
+        result = detect_outliers(m)
+        assert result == []
+
+    def test_empty_returns_empty(self):
+        # n < 2 case
+        m = np.empty((0, 5), dtype=np.float32)
+        result = detect_outliers(m)
+        assert result == []
+
+    def test_finds_outliers_in_synthetic_data(self):
+        rng = np.random.default_rng(42)
+        # Create a tight cluster with one obvious outlier
+        cluster = rng.standard_normal((50, 3)).astype(np.float32) * 0.1
+        outlier = np.array([[100.0, 100.0, 100.0]], dtype=np.float32)
+        m = np.vstack([cluster, outlier])
+        result = detect_outliers(m)
+        # The outlier (index 50) should be detected
+        outlier_indices = [idx for idx, _ in result]
+        assert 50 in outlier_indices
+
+    def test_returns_list_of_index_distance_tuples(self):
+        rng = np.random.default_rng(42)
+        # Tight cluster + outlier to guarantee at least one result
+        cluster = rng.standard_normal((20, 3)).astype(np.float32) * 0.1
+        far_point = np.array([[50.0, 50.0, 50.0]], dtype=np.float32)
+        m = np.vstack([cluster, far_point])
+        result = detect_outliers(m)
+        assert isinstance(result, list)
+        for item in result:
+            assert isinstance(item, tuple)
+            assert len(item) == 2
+            idx, dist = item
+            assert isinstance(idx, int)
+            assert isinstance(dist, float)
+            assert dist > 0
+
+    def test_iqr_cutoff_behavior(self):
+        """Lower IQR multiplier should flag more items than higher multiplier."""
+        rng = np.random.default_rng(42)
+        m = rng.standard_normal((100, 3)).astype(np.float32)
+        low = detect_outliers(m, iqr_multiplier=1.0, max_outlier_pct=0.5)
+        high = detect_outliers(m, iqr_multiplier=5.0, max_outlier_pct=0.5)
+        assert len(low) >= len(high)
+
+    def test_dimension_aware_no_mass_flagging(self):
+        """High-dimensional clean Gaussian data should not flag everything."""
+        rng = np.random.default_rng(42)
+        # 500 samples, 10 dims — well-conditioned for robust covariance
+        m = rng.standard_normal((500, 10)).astype(np.float32)
+        result = detect_outliers(m)
+        # With IQR-based cutoff on clean Gaussian data,
+        # only a small fraction should be flagged (well under 50%)
+        assert len(result) < 250
+
+    def test_contamination_parameter(self):
+        rng = np.random.default_rng(42)
+        m = rng.standard_normal((50, 3)).astype(np.float32)
+        # Should not raise with different contamination values
+        result = detect_outliers(m, contamination=0.05)
+        assert isinstance(result, list)
+
+    def test_max_outlier_pct_hard_cap(self):
+        """The hard cap should limit outlier count to max_outlier_pct * n."""
+        rng = np.random.default_rng(42)
+        # Create data with many potential outliers (bimodal)
+        cluster = rng.standard_normal((80, 3)).astype(np.float32) * 0.1
+        outliers = rng.standard_normal((20, 3)).astype(np.float32) * 50.0
+        m = np.vstack([cluster, outliers])
+        # Very low IQR multiplier to flag a lot, but cap at 5%
+        result = detect_outliers(m, iqr_multiplier=0.5, max_outlier_pct=0.05)
+        max_allowed = max(1, int(0.05 * 100))  # 5
+        assert len(result) <= max_allowed
+
+    def test_hard_cap_keeps_most_extreme(self):
+        """When capped, the most extreme items (highest distance) should be kept."""
+        rng = np.random.default_rng(42)
+        cluster = rng.standard_normal((90, 3)).astype(np.float32) * 0.1
+        # Create outliers with increasing extremity
+        outliers = np.array([
+            [10.0, 10.0, 10.0],
+            [20.0, 20.0, 20.0],
+            [50.0, 50.0, 50.0],
+        ], dtype=np.float32)
+        m = np.vstack([cluster, outliers])
+        # Cap at ~1 item (0.01 * 93 = 0, but min is 1)
+        result = detect_outliers(m, iqr_multiplier=0.5, max_outlier_pct=0.02)
+        if len(result) > 0:
+            # The most extreme (index 92, distance for [50,50,50]) should be kept
+            indices = [idx for idx, _ in result]
+            assert 92 in indices
+
+    def test_cutoff_attribute(self):
+        """Returned result should carry a cutoff attribute."""
+        rng = np.random.default_rng(42)
+        m = rng.standard_normal((50, 3)).astype(np.float32)
+        result = detect_outliers(m)
+        assert hasattr(result, "cutoff")
+        assert isinstance(result.cutoff, float)
+        assert result.cutoff > 0
+
+
+class TestFindDuplicatePairs:
+    """Tests for cosine similarity duplicate detection."""
+
+    def test_single_item_returns_empty(self):
+        m = np.random.randn(1, 10).astype(np.float32)
+        result = find_duplicate_pairs(m, 0.9)
+        assert result == []
+
+    def test_empty_returns_empty(self):
+        m = np.empty((0, 10), dtype=np.float32)
+        result = find_duplicate_pairs(m, 0.9)
+        assert result == []
+
+    def test_identical_vectors_detected(self):
+        vec = np.random.randn(10).astype(np.float32)
+        vec = vec / np.linalg.norm(vec)
+        m = np.vstack([vec, vec, np.random.randn(10).astype(np.float32)])
+        result = find_duplicate_pairs(m, 0.99)
+        # Items 0 and 1 are identical, should be found
+        assert any(i == 0 and j == 1 for i, j, _ in result)
+
+    def test_orthogonal_vectors_not_detected(self):
+        m = np.eye(5, dtype=np.float32)
+        result = find_duplicate_pairs(m, 0.5)
+        assert result == []
+
+    def test_returns_correct_format(self):
+        vec = np.random.randn(10).astype(np.float32)
+        vec = vec / np.linalg.norm(vec)
+        m = np.vstack([vec, vec])
+        result = find_duplicate_pairs(m, 0.5)
+        assert len(result) >= 1
+        for item in result:
+            assert len(item) == 3
+            i, j, sim = item
+            assert isinstance(i, int)
+            assert isinstance(j, int)
+            assert isinstance(sim, float)
+            assert i < j
+
+    def test_i_less_than_j(self):
+        rng = np.random.default_rng(42)
+        # Create some similar vectors
+        base = rng.standard_normal(10).astype(np.float32)
+        m = np.vstack([base + rng.standard_normal(10) * 0.01 for _ in range(5)])
+        result = find_duplicate_pairs(m, 0.5)
+        for i, j, _ in result:
+            assert i < j
+
+    def test_high_threshold_fewer_pairs(self):
+        rng = np.random.default_rng(42)
+        m = rng.standard_normal((10, 20)).astype(np.float32)
+        # Normalize for meaningful cosine similarities
+        norms = np.linalg.norm(m, axis=1, keepdims=True)
+        m = m / norms
+        low = find_duplicate_pairs(m, 0.3)
+        high = find_duplicate_pairs(m, 0.9)
+        assert len(low) >= len(high)
+
+
+class TestSuggestLabels:
+    """Tests for z-score normalized label suggestion."""
+
+    def test_empty_items_returns_empty_lists(self):
+        items = np.empty((0, 10), dtype=np.float32)
+        labels = np.random.randn(3, 10).astype(np.float32)
+        result = suggest_labels(items, labels, ["a", "b", "c"])
+        assert result == []
+
+    def test_empty_labels_returns_empty_per_item(self):
+        items = np.random.randn(5, 10).astype(np.float32)
+        labels = np.empty((0, 10), dtype=np.float32)
+        result = suggest_labels(items, labels, [])
+        assert len(result) == 5
+        assert all(s == [] for s in result)
+
+    def test_identical_embedding_gets_that_label(self):
+        """If an item embedding strongly matches one label, z-score should highlight it."""
+        # Create multiple items so z-score normalization is meaningful
+        rng = np.random.default_rng(42)
+        # 10 random items + 1 item that matches label "bug" exactly
+        random_items = rng.standard_normal((10, 3)).astype(np.float32)
+        bug_vec = np.array([[1.0, 0.0, 0.0]], dtype=np.float32)
+        items = np.vstack([random_items, bug_vec])
+        labels = np.array([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], dtype=np.float32)
+        result = suggest_labels(
+            items, labels, ["bug", "feature", "docs"],
+            z_threshold=0.5, z_margin=0.0, min_raw_sim=0.1,
+        )
+        # The last item (matching bug_vec) should get "bug" as top suggestion
+        last_item_sugs = result[-1]
+        if last_item_sugs:
+            assert last_item_sugs[0][0] == "bug"
+
+    def test_z_score_suppresses_dominant_label(self):
+        """When all items are similar to one label, z-scores should be low
+        (none stands out) and that label should not be blindly suggested."""
+        # All items identical — z-score for every item on every label is 0
+        items = np.ones((10, 3), dtype=np.float32)
+        labels = np.array([[1.0, 1.0, 1.0], [0.0, 1.0, 0.0]], dtype=np.float32)
+        result = suggest_labels(
+            items, labels, ["catch-all", "specific"],
+            z_threshold=1.5, min_raw_sim=0.3,
+        )
+        # With identical items, std=0 -> z-scores are all 0 -> nothing passes z_threshold
+        for sugs in result:
+            assert sugs == []
+
+    def test_margin_gate_blocks_top1(self):
+        """Top-1 label must beat #2 by z_margin to be accepted as position 0."""
+        rng = np.random.default_rng(99)
+        # 20 items, each slightly different, 2 labels
+        items = rng.standard_normal((20, 5)).astype(np.float32)
+        # Two labels that are nearly identical -> margin gate should block top-1
+        labels = np.array([[1.0, 0.5, 0.0, 0.0, 0.0],
+                           [1.0, 0.5, 0.01, 0.0, 0.0]], dtype=np.float32)
+        result = suggest_labels(
+            items, labels, ["label-a", "label-b"],
+            z_threshold=0.0, z_margin=10.0, min_raw_sim=0.0, max_per_item=1,
+        )
+        # With a huge margin requirement and max_per_item=1, nothing should pass
+        # because the only candidate (top-1) is blocked by margin gate,
+        # and max_per_item=1 prevents falling through to position 2
+        for sugs in result:
+            assert sugs == []
+
+    def test_margin_gate_passes_when_clear_winner(self):
+        """When top-1 clearly beats #2, it should pass the margin gate."""
+        # Create items where one strongly matches label 0 vs label 1
+        items = np.array([
+            [1.0, 0.0, 0.0, 0.0, 0.0],   # strongly matches label-a
+            [0.0, 0.0, 0.0, 0.0, 1.0],   # matches neither well
+        ] * 5, dtype=np.float32)  # 10 items for stable z-scores
+        labels = np.array([
+            [1.0, 0.0, 0.0, 0.0, 0.0],   # label-a
+            [0.0, 1.0, 0.0, 0.0, 0.0],   # label-b (orthogonal)
+        ], dtype=np.float32)
+        result = suggest_labels(
+            items, labels, ["label-a", "label-b"],
+            z_threshold=0.5, z_margin=0.3, min_raw_sim=0.1,
+        )
+        # Items matching label-a should get it suggested (clear z-score advantage)
+        got_label_a = sum(1 for sugs in result if sugs and sugs[0][0] == "label-a")
+        assert got_label_a > 0
+
+    def test_min_raw_similarity_filter(self):
+        """Even with high z-score, low raw similarity should be filtered out."""
+        # Items are orthogonal to all labels -> raw similarity near 0
+        items = np.array([[1.0, 0.0, 0.0]], dtype=np.float32)
+        labels = np.array([[0.0, 0.0, 1.0]], dtype=np.float32)
+        result = suggest_labels(
+            items, labels, ["irrelevant"],
+            z_threshold=0.0, z_margin=0.0, min_raw_sim=0.9,
+        )
+        # Raw similarity is ~0, which is below min_raw_sim=0.9
+        assert result[0] == []
+
+    def test_max_per_item_respected(self):
+        """Even if many labels qualify, max_per_item caps the results."""
+        rng = np.random.default_rng(42)
+        # Create items with some variance so z-scores differentiate
+        items = rng.standard_normal((20, 10)).astype(np.float32)
+        base = items[0]
+        # All labels very similar to item 0
+        labels = np.array([base + rng.standard_normal(10) * 0.01 for _ in range(10)])
+        names = [f"label-{i}" for i in range(10)]
+        result = suggest_labels(
+            items, labels, names,
+            z_threshold=0.0, z_margin=0.0, min_raw_sim=0.0, max_per_item=2,
+        )
+        for sugs in result:
+            assert len(sugs) <= 2
+
+    def test_returns_raw_similarity_not_z_score(self):
+        """Returned scores should be raw cosine similarity, not z-scores."""
+        rng = np.random.default_rng(42)
+        items = rng.standard_normal((15, 5)).astype(np.float32)
+        labels = rng.standard_normal((3, 5)).astype(np.float32)
+        names = ["bug", "feature", "docs"]
+        result = suggest_labels(
+            items, labels, names,
+            z_threshold=0.0, z_margin=0.0, min_raw_sim=-1.0,
+        )
+        # Raw cosine similarity should be in [-1, 1] range
+        for sugs in result:
+            for name, score in sugs:
+                assert -1.0 <= score <= 1.0 + 1e-5
+                assert isinstance(name, str)
+                assert isinstance(score, float)
+
+    def test_returns_correct_format(self):
+        rng = np.random.default_rng(42)
+        items = rng.standard_normal((3, 10)).astype(np.float32)
+        labels = rng.standard_normal((5, 10)).astype(np.float32)
+        names = ["bug", "feature", "docs", "ci", "test"]
+        result = suggest_labels(
+            items, labels, names,
+            z_threshold=0.0, z_margin=0.0, min_raw_sim=-1.0,
+        )
+        assert len(result) == 3
+        for sugs in result:
+            for name, score in sugs:
+                assert isinstance(name, str)
+                assert isinstance(score, float)
+                assert name in names
+
+    def test_text_truncation_in_labels(self):
+        """Label names should be returned as-is even when very long."""
+        rng = np.random.default_rng(42)
+        items = rng.standard_normal((10, 5)).astype(np.float32)
+        long_name = "a" * 200
+        labels = rng.standard_normal((1, 5)).astype(np.float32)
+        result = suggest_labels(
+            items, labels, [long_name],
+            z_threshold=0.0, z_margin=0.0, min_raw_sim=-1.0,
+        )
+        for sugs in result:
+            if sugs:
+                assert sugs[0][0] == long_name

.github/scripts/triage/test_sweep.py

@@ -0,0 +1,873 @@
+"""Tests for sweep.py — all external calls (API, embedding) are mocked."""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from io import BytesIO
+from unittest.mock import patch, MagicMock, mock_open
+from urllib.error import HTTPError
+
+import numpy as np
+import pytest
+
+# Mock fastembed before importing sweep (which imports embedding_utils)
+sys.modules["fastembed"] = MagicMock()
+
+# Set required env vars before importing sweep (module-level constants read env)
+os.environ.setdefault("GITHUB_TOKEN", "test-token")
+os.environ.setdefault("GITHUB_REPOSITORY", "owner/repo")
+
+from sweep import (
+    github_api_get,
+    fetch_all_open_items,
+    fetch_repo_labels,
+    apply_labels_to_item,
+    generate_report,
+    create_report_issue,
+    write_report,
+    main,
+    TriageItem,
+    RepoLabel,
+    REPORT_FILE,
+    REPORT_LABEL,
+    API_PAGE_SIZE,
+    MIN_SAMPLES_FOR_OUTLIER_DETECTION,
+    PCA_MAX_COMPONENTS,
+    MAX_EMBED_CHARS,
+    IQR_MULTIPLIER,
+    MAX_OUTLIER_PCT,
+    _item_age,
+    _suggested_action,
+)
+
+
+def _make_api_issue(number: int, title: str = "Test issue", is_pr: bool = False,
+                    body: str = "Issue body", labels: list[str] | None = None,
+                    created_at: str = "2026-03-21T00:00:00Z") -> dict:
+    """Helper to build a mock GitHub API issue response object."""
+    result: dict = {
+        "number": number,
+        "title": title,
+        "html_url": f"https://github.com/owner/repo/issues/{number}",
+        "body": body,
+        "created_at": created_at,
+        "labels": [{"name": lbl} for lbl in (labels or [])],
+    }
+    if is_pr:
+        result["pull_request"] = {"url": "..."}
+    return result
+
+
+class TestGithubApiGet:
+    """Tests for the github_api_get function."""
+
+    @patch("sweep.urllib.request.urlopen")
+    def test_successful_request(self, mock_urlopen):
+        mock_resp = MagicMock()
+        mock_resp.read.return_value = json.dumps([{"id": 1}]).encode()
+        mock_resp.__enter__ = lambda s: s
+        mock_resp.__exit__ = MagicMock(return_value=False)
+        mock_urlopen.return_value = mock_resp
+
+        result = github_api_get("/issues?state=open")
+        assert result == [{"id": 1}]
+
+    @patch("sweep.urllib.request.urlopen")
+    def test_http_error_exits(self, mock_urlopen):
+        error = HTTPError(
+            url="https://api.github.com/repos/owner/repo/issues",
+            code=403,
+            msg="Forbidden",
+            hdrs=None,  # type: ignore[arg-type]
+            fp=BytesIO(b'{"message": "rate limited"}'),
+        )
+        mock_urlopen.side_effect = error
+
+        with pytest.raises(SystemExit) as exc_info:
+            github_api_get("/issues")
+        assert exc_info.value.code == 1
+
+
+class TestConstants:
+    """Tests for module-level constants."""
+
+    def test_min_samples_is_at_least_3x_pca_max(self):
+        """MIN_SAMPLES must be >= 3 * PCA_MAX_COMPONENTS for reliable covariance."""
+        assert MIN_SAMPLES_FOR_OUTLIER_DETECTION >= 3 * PCA_MAX_COMPONENTS
+
+    def test_min_samples_is_100(self):
+        assert MIN_SAMPLES_FOR_OUTLIER_DETECTION == 100
+
+    def test_pca_max_components_is_20(self):
+        assert PCA_MAX_COMPONENTS == 20
+
+    def test_iqr_multiplier_default(self):
+        assert IQR_MULTIPLIER == 3.0
+
+    def test_max_outlier_pct_default(self):
+        assert MAX_OUTLIER_PCT == 0.05
+
+
+class TestFetchAllOpenItems:
+    """Tests for fetch_all_open_items."""
+
+    @patch("sweep.github_api_get")
+    def test_empty_repo(self, mock_get):
+        mock_get.return_value = []
+        items = fetch_all_open_items()
+        assert items == []
+
+    @patch("sweep.github_api_get")
+    def test_single_page(self, mock_get):
+        mock_get.return_value = [
+            _make_api_issue(1, "Bug report"),
+            _make_api_issue(2, "Feature request", is_pr=True),
+        ]
+        items = fetch_all_open_items()
+        assert len(items) == 2
+        assert items[0]["number"] == 1
+        assert items[0]["is_pr"] is False
+        assert items[1]["is_pr"] is True
+
+    @patch("sweep.github_api_get")
+    def test_text_field_constructed(self, mock_get):
+        mock_get.return_value = [
+            _make_api_issue(1, "My Title", body="My Body"),
+        ]
+        items = fetch_all_open_items()
+        assert items[0]["text"] == "My Title\n\nMy Body"
+
+    @patch("sweep.github_api_get")
+    def test_long_body_truncated(self, mock_get):
+        """Bodies exceeding MAX_EMBED_CHARS are truncated to fit the token window."""
+        long_body = "x" * (MAX_EMBED_CHARS + 500)
+        mock_get.return_value = [
+            _make_api_issue(1, "Title", body=long_body),
+        ]
+        items = fetch_all_open_items()
+        assert len(items[0]["text"]) == MAX_EMBED_CHARS
+
+    @patch("sweep.github_api_get")
+    def test_short_body_not_truncated(self, mock_get):
+        """Bodies under the limit are left intact."""
+        mock_get.return_value = [
+            _make_api_issue(1, "Title", body="Short body"),
+        ]
+        items = fetch_all_open_items()
+        assert items[0]["text"] == "Title\n\nShort body"
+
+    @patch("sweep.github_api_get")
+    def test_null_body_handled(self, mock_get):
+        issue = _make_api_issue(1, "No body")
+        issue["body"] = None
+        mock_get.return_value = [issue]
+        items = fetch_all_open_items()
+        assert items[0]["text"] == "No body\n\n"
+
+    @patch("sweep.github_api_get")
+    def test_labels_extracted(self, mock_get):
+        mock_get.return_value = [
+            _make_api_issue(1, "Labeled", labels=["bug", "high-priority"]),
+        ]
+        items = fetch_all_open_items()
+        assert items[0]["labels"] == ["bug", "high-priority"]
+
+    @patch("sweep.MAX_ITEMS", 3)
+    @patch("sweep.github_api_get")
+    def test_max_items_cap(self, mock_get):
+        mock_get.return_value = [_make_api_issue(i) for i in range(100)]
+        items = fetch_all_open_items()
+        assert len(items) == 3
+
+    @patch("sweep.API_PAGE_SIZE", 2)
+    @patch("sweep.github_api_get")
+    def test_pagination(self, mock_get):
+        # First page: 2 items (full page), second page: 1 item (partial -> stop)
+        mock_get.side_effect = [
+            [_make_api_issue(1), _make_api_issue(2)],
+            [_make_api_issue(3)],
+        ]
+        items = fetch_all_open_items()
+        assert len(items) == 3
+        assert mock_get.call_count == 2
+
+
+class TestItemAge:
+    """Tests for _item_age helper."""
+
+    def test_recent_item(self):
+        from datetime import datetime, timezone, timedelta
+        recent = (datetime.now(timezone.utc) - timedelta(hours=12)).isoformat()
+        assert _item_age(recent) == "<1d"
+
+    def test_days_old(self):
+        from datetime import datetime, timezone, timedelta
+        old = (datetime.now(timezone.utc) - timedelta(days=15)).isoformat()
+        assert _item_age(old) == "15d"
+
+    def test_months_old(self):
+        from datetime import datetime, timezone, timedelta
+        old = (datetime.now(timezone.utc) - timedelta(days=90)).isoformat()
+        assert _item_age(old) == "3mo"
+
+    def test_years_old(self):
+        from datetime import datetime, timezone, timedelta
+        old = (datetime.now(timezone.utc) - timedelta(days=400)).isoformat()
+        assert _item_age(old) == "1y"
+
+    def test_invalid_date(self):
+        assert _item_age("not-a-date") == "?"
+
+
+class TestSuggestedAction:
+    """Tests for _suggested_action helper."""
+
+    def test_both_issues_close_newer(self):
+        a = TriageItem(
+            number=1, title="A", html_url="u", is_pr=False, labels=[],
+            created_at="2026-01-01T00:00:00Z", text="t",
+        )
+        b = TriageItem(
+            number=2, title="B", html_url="u", is_pr=False, labels=[],
+            created_at="2026-02-01T00:00:00Z", text="t",
+        )
+        result = _suggested_action(a, b)
+        assert "Close #2 as duplicate" in result
+
+    def test_both_prs_review(self):
+        a = TriageItem(
+            number=1, title="A", html_url="u", is_pr=True, labels=[],
+            created_at="2026-01-01T00:00:00Z", text="t",
+        )
+        b = TriageItem(
+            number=2, title="B", html_url="u", is_pr=True, labels=[],
+            created_at="2026-01-01T00:00:00Z", text="t",
+        )
+        assert _suggested_action(a, b) == "Review for overlap"
+
+    def test_issue_pr_link(self):
+        a = TriageItem(
+            number=1, title="A", html_url="u", is_pr=False, labels=[],
+            created_at="2026-01-01T00:00:00Z", text="t",
+        )
+        b = TriageItem(
+            number=2, title="B", html_url="u", is_pr=True, labels=[],
+            created_at="2026-01-01T00:00:00Z", text="t",
+        )
+        assert _suggested_action(a, b) == "Link PR to issue"
+
+
+class TestGenerateReport:
+    """Tests for the markdown report generator."""
+
+    def test_no_findings(self):
+        items = [
+            TriageItem(
+                number=1, title="Test", html_url="https://example.com/1",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text="Test",
+            ),
+        ]
+        report = generate_report(items, [], [])
+        assert "## Triage Sweep Report" in report
+        assert "Items analyzed:** 1" in report
+        assert "None found." in report
+        assert "0 outliers flagged" in report
+        assert "0 duplicate pairs found" in report
+
+    def test_health_summary_table(self):
+        items = [
+            TriageItem(
+                number=1, title="Test", html_url="https://example.com/1",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text="Test",
+            ),
+        ]
+        report = generate_report(items, [], [])
+        assert "### Health Summary" in report
+        assert "| Metric | Value |" in report
+        assert "| Items analyzed | 1 |" in report
+
+    def test_iqr_multiplier_in_thresholds(self):
+        """Report should show IQR multiplier, not percentile."""
+        items = [
+            TriageItem(
+                number=1, title="Test", html_url="https://example.com/1",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text="Test",
+            ),
+        ]
+        report = generate_report(items, [], [])
+        assert "IQR multiplier" in report
+        assert "percentile" not in report.lower().split("thresholds")[0]  # not in thresholds line
+
+    def test_with_outliers_shows_distance_and_age(self):
+        items = [
+            TriageItem(
+                number=10, title="Spam Issue", html_url="https://example.com/10",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text="spam",
+            ),
+            TriageItem(
+                number=20, title="Good Issue", html_url="https://example.com/20",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text="good",
+            ),
+        ]
+        report = generate_report(items, [(0, 12.34)], [])
+        assert "#10" in report
+        assert "Spam Issue" in report
+        assert "12.34" in report
+        assert "1 outliers flagged" in report
+        # Age column should be present
+        assert "| Age |" in report
+
+    def test_outlier_borderline_in_details(self):
+        """Borderline outliers should be in a <details> section."""
+        from embedding_utils import _OutlierResult
+        items = [
+            TriageItem(
+                number=10, title="Borderline", html_url="https://example.com/10",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text="spam",
+            ),
+        ]
+        # Create outlier results with cutoff=10.0, distance=12.0 (< 2*cutoff=20)
+        outlier_results = _OutlierResult([(0, 12.0)])
+        outlier_results.cutoff = 10.0
+        report = generate_report(items, outlier_results, [])
+        assert "<details>" in report
+        assert "Borderline" in report
+
+    def test_outlier_high_confidence(self):
+        """Items with distance > 2x cutoff should be in high confidence section."""
+        from embedding_utils import _OutlierResult
+        items = [
+            TriageItem(
+                number=10, title="Definite Spam", html_url="https://example.com/10",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text="spam",
+            ),
+        ]
+        outlier_results = _OutlierResult([(0, 25.0)])
+        outlier_results.cutoff = 10.0
+        report = generate_report(items, outlier_results, [])
+        assert "High Confidence" in report
+
+    def test_with_duplicates_suggested_action(self):
+        items = [
+            TriageItem(
+                number=1, title="First", html_url="https://example.com/1",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text="a",
+            ),
+            TriageItem(
+                number=2, title="Second", html_url="https://example.com/2",
+                is_pr=True, labels=[], created_at="2026-02-01T00:00:00Z", text="b",
+            ),
+        ]
+        report = generate_report(items, [], [(0, 1, 0.954)])
+        assert "#1" in report
+        assert "#2" in report
+        assert "0.954" in report
+        assert "1 duplicate pairs found" in report
+        assert "Suggested Action" in report
+        assert "Link PR to issue" in report
+
+    def test_duplicate_both_issues_close_newer(self):
+        items = [
+            TriageItem(
+                number=1, title="First", html_url="https://example.com/1",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text="a",
+            ),
+            TriageItem(
+                number=2, title="Second", html_url="https://example.com/2",
+                is_pr=False, labels=[], created_at="2026-02-01T00:00:00Z", text="b",
+            ),
+        ]
+        report = generate_report(items, [], [(0, 1, 0.95)])
+        assert "Close #2 as duplicate" in report
+
+    def test_duplicate_both_prs_review(self):
+        items = [
+            TriageItem(
+                number=1, title="PR A", html_url="https://example.com/1",
+                is_pr=True, labels=[], created_at="2026-01-01T00:00:00Z", text="a",
+            ),
+            TriageItem(
+                number=2, title="PR B", html_url="https://example.com/2",
+                is_pr=True, labels=[], created_at="2026-01-01T00:00:00Z", text="b",
+            ),
+        ]
+        report = generate_report(items, [], [(0, 1, 0.95)])
+        assert "Review for overlap" in report
+
+    def test_pr_type_label(self):
+        items = [
+            TriageItem(
+                number=5, title="PR Title", html_url="https://example.com/5",
+                is_pr=True, labels=[], created_at="2026-01-01T00:00:00Z", text="pr",
+            ),
+        ]
+        report = generate_report(items, [(0, 8.5)], [])
+        assert "| PR |" in report
+
+    def test_footer_present(self):
+        items = [
+            TriageItem(
+                number=1, title="T", html_url="u",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text="t",
+            ),
+        ]
+        report = generate_report(items, [], [])
+        assert "no LLM was used" in report
+
+
+class TestCreateReportIssue:
+    """Tests for creating the report GitHub issue."""
+
+    @patch("sweep.urllib.request.urlopen")
+    def test_successful_creation(self, mock_urlopen):
+        mock_resp = MagicMock()
+        mock_resp.status = 201
+        mock_resp.read.return_value = json.dumps({
+            "html_url": "https://github.com/owner/repo/issues/99",
+        }).encode()
+        mock_resp.__enter__ = lambda s: s
+        mock_resp.__exit__ = MagicMock(return_value=False)
+        mock_urlopen.return_value = mock_resp
+
+        # Should not raise
+        create_report_issue("# Test Report")
+
+    @patch("sweep.urllib.request.urlopen")
+    def test_http_error_exits(self, mock_urlopen):
+        error = HTTPError(
+            url="https://api.github.com/repos/owner/repo/issues",
+            code=422,
+            msg="Unprocessable",
+            hdrs=None,  # type: ignore[arg-type]
+            fp=BytesIO(b'{"message": "validation failed"}'),
+        )
+        mock_urlopen.side_effect = error
+
+        with pytest.raises(SystemExit) as exc_info:
+            create_report_issue("# Test Report")
+        assert exc_info.value.code == 1
+
+
+class TestWriteReport:
+    """Tests for the write_report helper."""
+
+    @patch("builtins.open", mock_open())
+    def test_writes_to_file(self):
+        write_report("# Report Content")
+        from builtins import open as builtin_open  # noqa
+        # Verify open was called with the right path
+        from unittest.mock import call
+        open_mock = open  # The patched version
+        open_mock.assert_called_once_with(REPORT_FILE, "w", encoding="utf-8")  # type: ignore[attr-defined]
+        open_mock().write.assert_called_once_with("# Report Content")  # type: ignore[attr-defined]
+
+
+class TestFetchRepoLabels:
+    """Tests for fetch_repo_labels."""
+
+    @patch("sweep.github_api_get")
+    def test_fetches_and_constructs_labels(self, mock_get):
+        mock_get.return_value = [
+            {"name": "bug", "description": "Something isn't working"},
+            {"name": "enhancement", "description": "New feature or request"},
+            {"name": "docs", "description": ""},
+        ]
+        labels = fetch_repo_labels()
+        assert len(labels) == 3
+        assert labels[0]["name"] == "bug"
+        assert labels[0]["text"] == "bug: Something isn't working"
+        assert labels[2]["text"] == "docs"  # no description, just name
+
+    @patch("sweep.github_api_get")
+    def test_empty_repo_labels(self, mock_get):
+        mock_get.return_value = []
+        labels = fetch_repo_labels()
+        assert labels == []
+
+    @patch("sweep.github_api_get")
+    def test_null_description_handled(self, mock_get):
+        mock_get.return_value = [
+            {"name": "wontfix", "description": None},
+        ]
+        labels = fetch_repo_labels()
+        assert labels[0]["text"] == "wontfix"
+
+    @patch("sweep.API_PAGE_SIZE", 2)
+    @patch("sweep.github_api_get")
+    def test_label_pagination(self, mock_get):
+        """Repos with more labels than one page should fetch all pages."""
+        mock_get.side_effect = [
+            # First page: full (2 items = API_PAGE_SIZE)
+            [
+                {"name": "bug", "description": "Broken"},
+                {"name": "feature", "description": "New"},
+            ],
+            # Second page: partial (1 item < API_PAGE_SIZE) -> stop
+            [
+                {"name": "docs", "description": "Documentation"},
+            ],
+        ]
+        labels = fetch_repo_labels()
+        assert len(labels) == 3
+        assert mock_get.call_count == 2
+        assert labels[0]["name"] == "bug"
+        assert labels[2]["name"] == "docs"
+
+
+class TestApplyLabelsToItem:
+    """Tests for apply_labels_to_item."""
+
+    def test_empty_labels_skips(self):
+        # Should not make any API call
+        apply_labels_to_item(1, [])
+
+    @patch("sweep.urllib.request.urlopen")
+    def test_successful_label_application(self, mock_urlopen):
+        mock_resp = MagicMock()
+        mock_resp.read.return_value = b'[{"name": "bug"}]'
+        mock_resp.__enter__ = lambda s: s
+        mock_resp.__exit__ = MagicMock(return_value=False)
+        mock_urlopen.return_value = mock_resp
+
+        # Should not raise
+        apply_labels_to_item(42, ["bug", "enhancement"])
+
+    @patch("sweep.urllib.request.urlopen")
+    def test_http_error_is_non_fatal(self, mock_urlopen):
+        error = HTTPError(
+            url="https://api.github.com/repos/owner/repo/issues/1/labels",
+            code=404,
+            msg="Not Found",
+            hdrs=None,  # type: ignore[arg-type]
+            fp=BytesIO(b'{"message": "not found"}'),
+        )
+        mock_urlopen.side_effect = error
+
+        # Should NOT raise — labeling failures are warnings, not fatal
+        apply_labels_to_item(1, ["bug"])
+
+
+class TestGenerateReportWithLabels:
+    """Tests for label suggestions in the report."""
+
+    def test_report_includes_label_section_high_confidence(self):
+        """High-confidence label (raw_sim >= 0.5) should appear in main table."""
+        items = [
+            TriageItem(
+                number=1, title="Fix crash", html_url="https://example.com/1",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text="crash",
+            ),
+        ]
+        suggestions = [[("bug", 0.85)]]
+        report = generate_report(items, [], [], label_suggestions=suggestions)
+        assert "Suggested Labels" in report
+        assert "`bug` (0.85)" in report
+        assert "1 items suggested for labeling" in report
+
+    def test_report_low_confidence_in_details(self):
+        """Low-confidence label (raw_sim < 0.5) should be in <details> section."""
+        items = [
+            TriageItem(
+                number=1, title="Something", html_url="https://example.com/1",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text="something",
+            ),
+        ]
+        suggestions = [[("maybe-bug", 0.35)]]
+        report = generate_report(items, [], [], label_suggestions=suggestions)
+        assert "Low-confidence suggestions" in report
+        assert "<details>" in report
+        assert "`maybe-bug` (0.35)" in report
+
+    def test_report_skips_already_labeled_items(self):
+        items = [
+            TriageItem(
+                number=1, title="Already labeled", html_url="https://example.com/1",
+                is_pr=False, labels=["bug"], created_at="2026-01-01T00:00:00Z", text="bug",
+            ),
+        ]
+        suggestions = [[("bug", 0.95)]]
+        report = generate_report(items, [], [], label_suggestions=suggestions)
+        assert "0 items suggested for labeling" in report
+        assert "No unlabeled items" in report
+
+    def test_report_excludes_outliers_from_suggestions(self):
+        items = [
+            TriageItem(
+                number=1, title="Spam garbage", html_url="https://example.com/1",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text="spam",
+            ),
+            TriageItem(
+                number=2, title="Real bug", html_url="https://example.com/2",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text="bug",
+            ),
+        ]
+        suggestions = [[("bug", 0.85)], [("bug", 0.90)]]
+        # Item 0 is an outlier (with distance) — should be excluded from label suggestions
+        report = generate_report(items, [(0, 15.2)], [], label_suggestions=suggestions)
+        assert "1 unlabeled items" in report  # only item 2
+        assert "#2" in report
+        # Item 0 (outlier) should NOT be in the suggestions table
+        assert "Spam garbage" not in report.split("Suggested Labels")[1]
+
+    def test_report_without_label_suggestions(self):
+        items = [
+            TriageItem(
+                number=1, title="T", html_url="u",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text="t",
+            ),
+        ]
+        report = generate_report(items, [], [], label_suggestions=None)
+        assert "Suggested Labels" not in report
+
+    def test_label_concentration_warning(self):
+        """When >50% of suggestions point to the same label, a warning should appear."""
+        items = [
+            TriageItem(
+                number=i, title=f"Item {i}", html_url=f"https://example.com/{i}",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text=f"text {i}",
+            )
+            for i in range(4)
+        ]
+        # 3 out of 4 items get "bug" label -> 75% concentration
+        suggestions = [
+            [("bug", 0.85)],
+            [("bug", 0.80)],
+            [("bug", 0.75)],
+            [("enhancement", 0.90)],
+        ]
+        report = generate_report(items, [], [], label_suggestions=suggestions)
+        assert "Warning" in report
+        assert "`bug`" in report
+        assert "3/4" in report
+
+
+class TestMain:
+    """Tests for the main orchestration function."""
+
+    @patch.dict(os.environ, {"GITHUB_TOKEN": "", "GITHUB_REPOSITORY": "owner/repo"})
+    def test_missing_token_exits(self):
+        with pytest.raises(SystemExit) as exc_info:
+            main()
+        assert exc_info.value.code == 1
+
+    @patch.dict(os.environ, {"GITHUB_TOKEN": "tok", "GITHUB_REPOSITORY": ""})
+    def test_missing_repo_exits(self):
+        with pytest.raises(SystemExit) as exc_info:
+            main()
+        assert exc_info.value.code == 1
+
+    @patch("sweep.write_report")
+    @patch("sweep.fetch_all_open_items", return_value=[])
+    def test_no_items(self, mock_fetch, mock_write):
+        main()
+        mock_write.assert_called_once()
+        report = mock_write.call_args[0][0]
+        assert "No open issues or PRs found" in report
+
+    @patch("sweep.create_report_issue")
+    @patch("sweep.write_report")
+    @patch("sweep.suggest_labels", return_value=[])
+    @patch("sweep.find_duplicate_pairs", return_value=[])
+    @patch("sweep.detect_outliers", return_value=[])
+    @patch("sweep.reduce_dimensions")
+    @patch("sweep.normalize_rows")
+    @patch("sweep.embed_texts")
+    @patch("sweep.fetch_repo_labels")
+    @patch("sweep.fetch_all_open_items")
+    def test_full_flow_with_enough_items(
+        self, mock_fetch, mock_labels, mock_embed, mock_norm, mock_reduce,
+        mock_outliers, mock_dupes, mock_suggest, mock_write, mock_create,
+    ):
+        """Test the full flow with >= MIN_SAMPLES items (outlier detection runs)."""
+        n = MIN_SAMPLES_FOR_OUTLIER_DETECTION
+        items = [
+            TriageItem(
+                number=i, title=f"Item {i}", html_url=f"https://example.com/{i}",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text=f"text {i}",
+            )
+            for i in range(n)
+        ]
+        mock_fetch.return_value = items
+        mock_labels.return_value = [
+            RepoLabel(name="bug", description="Something broken", text="bug: Something broken"),
+        ]
+
+        embeddings = np.random.randn(n, 384).astype(np.float32)
+        mock_embed.return_value = embeddings
+        mock_norm.return_value = embeddings
+        mock_reduce.return_value = np.random.randn(n, 10).astype(np.float32)
+
+        main()
+
+        mock_fetch.assert_called_once()
+        mock_labels.assert_called_once()
+        # embed_texts called twice: once for items, once for labels
+        assert mock_embed.call_count == 2
+        mock_norm.assert_called()
+        mock_reduce.assert_called_once()
+        mock_outliers.assert_called_once()
+        mock_dupes.assert_called_once()
+        mock_suggest.assert_called_once()
+        mock_write.assert_called_once()
+        mock_create.assert_called_once()
+
+    @patch("sweep.create_report_issue")
+    @patch("sweep.write_report")
+    @patch("sweep.suggest_labels", return_value=[])
+    @patch("sweep.find_duplicate_pairs", return_value=[])
+    @patch("sweep.detect_outliers")
+    @patch("sweep.reduce_dimensions")
+    @patch("sweep.normalize_rows")
+    @patch("sweep.embed_texts")
+    @patch("sweep.fetch_repo_labels", return_value=[])
+    @patch("sweep.fetch_all_open_items")
+    def test_skips_outlier_detection_for_few_items(
+        self, mock_fetch, mock_labels, mock_embed, mock_norm, mock_reduce,
+        mock_outliers, mock_dupes, mock_suggest, mock_write, mock_create,
+    ):
+        """With < MIN_SAMPLES items, outlier detection should be skipped."""
+        n = MIN_SAMPLES_FOR_OUTLIER_DETECTION - 1
+        items = [
+            TriageItem(
+                number=i, title=f"Item {i}", html_url=f"https://example.com/{i}",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text=f"text {i}",
+            )
+            for i in range(n)
+        ]
+        mock_fetch.return_value = items
+
+        embeddings = np.random.randn(n, 384).astype(np.float32)
+        mock_embed.return_value = embeddings
+        mock_norm.return_value = embeddings
+
+        main()
+
+        # Outlier detection should not have been called
+        mock_reduce.assert_not_called()
+        mock_outliers.assert_not_called()
+        # But duplicates should still be checked
+        mock_dupes.assert_called_once()
+
+    @patch.dict(os.environ, {"INPUT_DRY_RUN": "true"})
+    @patch("sweep.DRY_RUN", True)
+    @patch("sweep.write_report")
+    @patch("sweep.create_report_issue")
+    @patch("sweep.apply_labels_to_item")
+    @patch("sweep.suggest_labels", return_value=[[("bug", 0.85)]])
+    @patch("sweep.find_duplicate_pairs", return_value=[])
+    @patch("sweep.normalize_rows")
+    @patch("sweep.embed_texts")
+    @patch("sweep.fetch_repo_labels")
+    @patch("sweep.fetch_all_open_items")
+    def test_dry_run_skips_issue_creation_and_labeling(
+        self, mock_fetch, mock_labels, mock_embed, mock_norm,
+        mock_dupes, mock_suggest, mock_apply, mock_create, mock_write,
+    ):
+        items = [
+            TriageItem(
+                number=1, title="Item", html_url="https://example.com/1",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text="text",
+            )
+        ]
+        mock_fetch.return_value = items
+        mock_labels.return_value = [
+            RepoLabel(name="bug", description="Broken", text="bug: Broken"),
+        ]
+        embeddings = np.random.randn(1, 384).astype(np.float32)
+        mock_embed.return_value = embeddings
+        mock_norm.return_value = embeddings
+
+        main()
+
+        mock_create.assert_not_called()
+        mock_apply.assert_not_called()
+        mock_write.assert_called_once()
+
+    @patch("sweep.create_report_issue")
+    @patch("sweep.write_report")
+    @patch("sweep.apply_labels_to_item")
+    @patch("sweep.suggest_labels")
+    @patch("sweep.find_duplicate_pairs", return_value=[])
+    @patch("sweep.normalize_rows")
+    @patch("sweep.embed_texts")
+    @patch("sweep.fetch_repo_labels")
+    @patch("sweep.fetch_all_open_items")
+    def test_labels_not_auto_applied(
+        self, mock_fetch, mock_labels, mock_embed, mock_norm,
+        mock_dupes, mock_suggest, mock_apply, mock_write, mock_create,
+    ):
+        """Auto-labeling is disabled; labels should appear in report only."""
+        items = [
+            TriageItem(
+                number=1, title="Crash bug", html_url="https://example.com/1",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text="crash",
+            ),
+            TriageItem(
+                number=2, title="Already labeled", html_url="https://example.com/2",
+                is_pr=False, labels=["enhancement"], created_at="2026-01-01T00:00:00Z", text="feat",
+            ),
+        ]
+        mock_fetch.return_value = items
+        mock_labels.return_value = [
+            RepoLabel(name="bug", description="Broken", text="bug: Broken"),
+        ]
+        mock_suggest.return_value = [
+            [("bug", 0.90)],
+            [("bug", 0.45)],
+        ]
+
+        embeddings = np.random.randn(2, 384).astype(np.float32)
+        mock_embed.return_value = embeddings
+        mock_norm.return_value = embeddings
+
+        main()
+
+        # Auto-labeling is disabled — apply_labels_to_item should never be called
+        mock_apply.assert_not_called()
+
+    @patch("sweep.create_report_issue")
+    @patch("sweep.write_report")
+    @patch("sweep.apply_labels_to_item")
+    @patch("sweep.suggest_labels")
+    @patch("sweep.find_duplicate_pairs", return_value=[])
+    @patch("sweep.detect_outliers")
+    @patch("sweep.reduce_dimensions")
+    @patch("sweep.normalize_rows")
+    @patch("sweep.embed_texts")
+    @patch("sweep.fetch_repo_labels")
+    @patch("sweep.fetch_all_open_items")
+    def test_outliers_excluded_from_report_suggestions(
+        self, mock_fetch, mock_labels, mock_embed, mock_norm, mock_reduce,
+        mock_outliers, mock_dupes, mock_suggest, mock_apply, mock_write, mock_create,
+    ):
+        """Items flagged as outliers should not appear in report label suggestions."""
+        n = MIN_SAMPLES_FOR_OUTLIER_DETECTION
+        items = [
+            TriageItem(
+                number=i, title=f"Item {i}", html_url=f"https://example.com/{i}",
+                is_pr=False, labels=[], created_at="2026-01-01T00:00:00Z", text=f"text {i}",
+            )
+            for i in range(n)
+        ]
+        mock_fetch.return_value = items
+        mock_labels.return_value = [
+            RepoLabel(name="bug", description="Broken", text="bug: Broken"),
+        ]
+        mock_outliers.return_value = [(0, 12.5), (5, 15.3)]
+        mock_suggest.return_value = [[("bug", 0.85)] for _ in range(n)]
+
+        embeddings = np.random.randn(n, 384).astype(np.float32)
+        mock_embed.return_value = embeddings
+        mock_norm.return_value = embeddings
+        mock_reduce.return_value = np.random.randn(n, 10).astype(np.float32)
+
+        main()
+
+        # Auto-labeling is disabled
+        mock_apply.assert_not_called()
+        # Report should still be generated (outliers excluded from suggestions in report)
+        mock_write.assert_called_once()
+        report = mock_write.call_args[0][0]
+        # Outlier items 0 and 5 should not appear in the label suggestions section
+        assert "Item 0" not in report.split("Suggested Labels")[1] if "Suggested Labels" in report else True

.github/workflows/ci-e2e.yml

@@ -0,0 +1,83 @@
+name: E2E Tests
+
+on:
+  workflow_call:
+
+jobs:
+  check-changes:
+    name: Check web module changes
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    outputs:
+      web_changed: ${{ steps.filter.outputs.web }}
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3
+        id: filter
+        with:
+          filters: |
+            web:
+              - 'gitnexus-web/**'
+
+  e2e:
+    name: e2e (chromium)
+    needs: check-changes
+    if: needs.check-changes.result == 'success' && needs.check-changes.outputs.web_changed == 'true'
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+
+      - uses: ./.github/actions/setup-gitnexus-web
+
+      - name: Install Playwright browsers
+        run: npx playwright install --with-deps chromium
+        working-directory: gitnexus-web
+
+      - name: Install backend dependencies
+        run: npm ci
+        working-directory: gitnexus
+
+      - name: Build backend
+        run: npm run build
+        working-directory: gitnexus
+
+      - name: Analyze repository (index for backend)
+        run: |
+          node gitnexus/dist/cli/index.js analyze || true
+          if [ ! -d ".gitnexus" ]; then
+            echo "::error::No .gitnexus index created"
+            exit 1
+          fi
+
+      - name: Start backend server
+        run: node dist/cli/index.js serve &
+        working-directory: gitnexus
+
+      - name: Wait for backend readiness
+        run: npx wait-on http://localhost:4747/api/repos --timeout 30000
+        working-directory: gitnexus-web
+
+      - name: Start Vite dev server
+        run: npm run dev &
+        working-directory: gitnexus-web
+
+      - name: Wait for Vite dev server
+        run: npx wait-on http://localhost:5173 --timeout 30000
+        working-directory: gitnexus-web
+
+      - name: Run E2E tests
+        run: npx playwright test
+        working-directory: gitnexus-web
+        env:
+          E2E: '1'
+
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+        with:
+          name: e2e-results
+          path: |
+            gitnexus-web/test-results/
+            gitnexus-web/playwright-report/
+          retention-days: 5

.github/workflows/ci-integration.yml

@@ -1,198 +0,0 @@
-name: Integration Tests
-
-on:
-  workflow_call:
-    inputs:
-      collect-coverage:
-        description: 'Whether to run the coverage collection job (only needed for PR reports)'
-        required: false
-        default: true
-        type: boolean
-
-jobs:
-  # ── Integration test matrix ─────────────────────────────────────────
-  # Each test-group runs on a SEPARATE runner per OS, giving full process
-  # isolation for the LadybugDB native C++ addon.
-  # 3 OS x 4 groups = 12 parallel jobs.
-  #
-  # Groups:
-  #   lbug-db    — 7 files using withTestLbugDB / lbug-adapter (native addon)
-  #                Each file runs as its own `vitest run` invocation for full
-  #                process isolation. LadybugDB's native N-API addon registers
-  #                persistent handles that prevent fork workers from exiting
-  #                on Linux, and its C++ destructors segfault during
-  #                process.exit(). Running each file in its own process lets
-  #                the OS reclaim all resources cleanly.
-  #   pipeline   — 12 files: ingestion pipeline + csv + 9 resolver tests
-  #   e2e        — 4 files: child-process only (spawnSync), no in-process lbug
-  #   standalone — 4 files: pure logic, no lbug, no child processes
-  test-matrix:
-    name: integration (${{ matrix.os }} / ${{ matrix.test-group }})
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        test-group: [lbug-db, pipeline, e2e, standalone]
-        include:
-          - test-group: lbug-db
-            # Marker — actual files are listed in the run step below
-            test-glob: ''
-          - test-group: pipeline
-            test-glob: >-
-              test/integration/pipeline.test.ts
-              test/integration/csv-pipeline.test.ts
-              test/integration/parsing.test.ts
-              test/integration/resolvers/typescript.test.ts
-              test/integration/resolvers/csharp.test.ts
-              test/integration/resolvers/cpp.test.ts
-              test/integration/resolvers/java.test.ts
-              test/integration/resolvers/python.test.ts
-              test/integration/resolvers/rust.test.ts
-              test/integration/resolvers/go.test.ts
-              test/integration/resolvers/kotlin.test.ts
-              test/integration/resolvers/php.test.ts
-              test/integration/resolvers/ruby.test.ts
-              test/integration/resolvers/swift.test.ts
-          - test-group: e2e
-            test-glob: >-
-              test/integration/cli-e2e.test.ts
-              test/integration/hooks-e2e.test.ts
-              test/integration/skills-e2e.test.ts
-              test/integration/ignore-and-skip-e2e.test.ts
-          - test-group: standalone
-            test-glob: >-
-              test/integration/filesystem-walker.test.ts
-              test/integration/enrichment.test.ts
-              test/integration/tree-sitter-languages.test.ts
-              test/integration/worker-pool.test.ts
-    runs-on: ${{ matrix.os }}
-    timeout-minutes: 25
-    steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-      - uses: ./.github/actions/setup-gitnexus
-        with:
-          build: 'true'
-
-      # lbug-db: run each file in its own vitest process for full isolation.
-      # LadybugDB's native addon hangs fork workers on Linux — process isolation
-      # is the only reliable fix boundary.
-      - name: Run integration tests — lbug-db (process-isolated)
-        if: matrix.test-group == 'lbug-db'
-        working-directory: gitnexus
-        shell: bash
-        run: |
-          set -e
-          files=(
-            test/integration/lbug-core-adapter.test.ts
-            test/integration/lbug-pool.test.ts
-            test/integration/local-backend.test.ts
-            test/integration/local-backend-calltool.test.ts
-            test/integration/search-core.test.ts
-            test/integration/search-pool.test.ts
-            test/integration/augmentation.test.ts
-          )
-          exit_code=0
-          for f in "${files[@]}"; do
-            echo "::group::$f"
-            if ! npx vitest run --reporter=verbose --pool=forks "$f"; then
-              exit_code=1
-              echo "::error::Test file failed: $f"
-            fi
-            echo "::endgroup::"
-          done
-          exit $exit_code
-
-      # Non-lbug groups: run all files in a single vitest invocation
-      - name: Run integration tests — ${{ matrix.test-group }}
-        if: matrix.test-group != 'lbug-db'
-        shell: bash
-        env:
-          TEST_GLOB: ${{ matrix.test-glob }}
-        run: npx vitest run --reporter=verbose $TEST_GLOB
-        working-directory: gitnexus
-
-  # ── Coverage collection (ubuntu only) ─────────────────────────────────
-  # Runs non-lbug integration tests with coverage enabled so the PR report
-  # can merge integration + unit coverage for a combined view.
-  # lbug-db tests are excluded because each file must run in its own vitest
-  # process (native addon isolation) which prevents single-run coverage merge.
-  coverage:
-    name: integration (ubuntu / coverage)
-    if: inputs.collect-coverage
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-      - uses: ./.github/actions/setup-gitnexus
-        with:
-          build: 'true'
-
-      - name: Run integration tests with coverage
-        working-directory: gitnexus
-        run: >-
-          npx vitest run
-          --reporter=default
-          --reporter=json
-          --outputFile=integration-results.json
-          --coverage
-          --coverage.reporter=json-summary
-          --coverage.reporter=json
-          --coverage.reporter=text
-          --coverage.thresholdAutoUpdate=false
-          --coverage.reportOnFailure=true
-          --coverage.thresholds.statements=0
-          --coverage.thresholds.branches=0
-          --coverage.thresholds.functions=0
-          --coverage.thresholds.lines=0
-          test/integration/pipeline.test.ts
-          test/integration/csv-pipeline.test.ts
-          test/integration/parsing.test.ts
-          test/integration/cli-e2e.test.ts
-          test/integration/hooks-e2e.test.ts
-          test/integration/filesystem-walker.test.ts
-          test/integration/enrichment.test.ts
-          test/integration/tree-sitter-languages.test.ts
-          test/integration/worker-pool.test.ts
-          test/integration/ignore-and-skip-e2e.test.ts
-          test/integration/resolvers/typescript.test.ts
-          test/integration/resolvers/csharp.test.ts
-          test/integration/resolvers/cpp.test.ts
-          test/integration/resolvers/java.test.ts
-          test/integration/resolvers/python.test.ts
-          test/integration/resolvers/rust.test.ts
-          test/integration/resolvers/go.test.ts
-          test/integration/resolvers/kotlin.test.ts
-          test/integration/resolvers/php.test.ts
-          test/integration/resolvers/ruby.test.ts
-          test/integration/resolvers/swift.test.ts
-
-      - name: Upload integration coverage
-        if: always()
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
-        with:
-          name: integration-reports
-          path: |
-            gitnexus/coverage/coverage-summary.json
-            gitnexus/coverage/coverage-final.json
-            gitnexus/integration-results.json
-          retention-days: 5
-
-  # ── Unified status gate ──────────────────────────────────────────────
-  # Branch protection should require THIS job, not the matrix jobs directly.
-  # ci.yml's needs.integration.result aggregates through this gate.
-  status:
-    name: integration (all groups)
-    needs: test-matrix
-    if: always()
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    steps:
-      - name: Check all matrix jobs passed
-        shell: bash
-        env:
-          RESULT: ${{ needs.test-matrix.result }}
-        run: |
-          if [[ "$RESULT" != "success" ]]; then
-            echo "::error::Integration matrix failed or cancelled: $RESULT"
-            exit 1
-          fi

.github/workflows/ci-quality.yml

@@ -4,6 +4,32 @@ on:
   workflow_call:
 
 jobs:
+  format:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        with:
+          node-version: 20
+          cache: npm
+          cache-dependency-path: package-lock.json
+      - run: npm ci
+      - run: npx prettier --check .
+
+  lint:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        with:
+          node-version: 20
+          cache: npm
+          cache-dependency-path: package-lock.json
+      - run: npm ci
+      - run: npx eslint .
+
   typecheck:
     runs-on: ubuntu-latest
     timeout-minutes: 10
@@ -12,3 +38,12 @@ jobs:
       - uses: ./.github/actions/setup-gitnexus
       - run: npx tsc --noEmit
         working-directory: gitnexus
+
+  typecheck-web:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: ./.github/actions/setup-gitnexus-web
+      - run: npx tsc -b --noEmit
+        working-directory: gitnexus-web

.github/workflows/ci-report.yml

@@ -6,12 +6,12 @@ name: CI Report
 
 on:
   workflow_run:
-    workflows: ["CI"]
+    workflows: ['CI']
     types: [completed]
 
 permissions:
-  actions: read        # needed to list/download workflow run artifacts
-  contents: read       # needed for sparse checkout of vitest.config.ts
+  actions: read # needed to list/download workflow run artifacts
+  contents: read # needed for sparse checkout of vitest.config.ts
   pull-requests: write # needed to post sticky PR comment
 
 jobs:
@@ -59,7 +59,6 @@ jobs:
             const temp = process.env.RUNNER_TEMP;
             await downloadArtifact('pr-meta', path.join(temp, 'dl'));
             await downloadArtifact('test-reports', path.join(temp, 'dl'));
-            await downloadArtifact('integration-reports', path.join(temp, 'dl'));
 
       - name: Extract artifacts
         shell: bash
@@ -109,8 +108,8 @@ jobs:
           }
 
           echo "quality=$(validate_result "$DIR/quality_result")"        >> "$GITHUB_OUTPUT"
-          echo "unit=$(validate_result "$DIR/unit_result")"              >> "$GITHUB_OUTPUT"
-          echo "integration=$(validate_result "$DIR/integration_result")" >> "$GITHUB_OUTPUT"
+          echo "tests=$(validate_result "$DIR/tests_result")"            >> "$GITHUB_OUTPUT"
+          echo "e2e=$(validate_result "$DIR/e2e_result")"                >> "$GITHUB_OUTPUT"
 
       - name: Checkout (for vitest config)
         if: steps.meta.outputs.skip != 'true'
@@ -177,78 +176,22 @@ jobs:
         shell: bash
         run: |
           cd "${{ steps.base-coverage.outputs.dir }}"
+          mkdir -p base
           unzip -o base.zip -d base
 
-      # ── Merge coverage from unit + integration ─────────────────────
-      - name: Setup Node.js
-        if: steps.meta.outputs.skip != 'true'
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
-        with:
-          node-version: 20
-
-      - name: Install coverage merge tools
-        if: steps.meta.outputs.skip != 'true'
-        run: npm install --no-save istanbul-lib-coverage istanbul-lib-report istanbul-reports
-
-      - name: Merge coverage reports
-        if: steps.meta.outputs.skip != 'true'
-        id: coverage
-        shell: bash
-        run: |
-          DIR="$RUNNER_TEMP/artifacts"
-          UNIT_COV=$(find "$DIR/test-reports" -name "coverage-final.json" -type f 2>/dev/null | head -1)
-          INTEG_COV=$(find "$DIR/integration-reports" -name "coverage-final.json" -type f 2>/dev/null | head -1)
-          MERGED_DIR="$RUNNER_TEMP/merged-coverage"
-          mkdir -p "$MERGED_DIR"
-
-          if [ -n "$UNIT_COV" ] && [ -n "$INTEG_COV" ]; then
-            echo "has_merged=true" >> "$GITHUB_OUTPUT"
-            # Merge using Node.js + istanbul-lib-coverage.
-            # Paths are passed via env vars to avoid shell interpolation
-            # inside the script string.
-            UNIT_COV_PATH="$UNIT_COV" \
-            INTEG_COV_PATH="$INTEG_COV" \
-            MERGED_OUT_DIR="$MERGED_DIR" \
-            node -e "
-              const libCoverage = require('istanbul-lib-coverage');
-              const libReport = require('istanbul-lib-report');
-              const reports = require('istanbul-reports');
-              const fs = require('fs');
-
-              const map = libCoverage.createCoverageMap({});
-              map.merge(JSON.parse(fs.readFileSync(process.env.UNIT_COV_PATH, 'utf8')));
-              map.merge(JSON.parse(fs.readFileSync(process.env.INTEG_COV_PATH, 'utf8')));
-
-              const context = libReport.createContext({
-                coverageMap: map,
-                dir: process.env.MERGED_OUT_DIR,
-              });
-              reports.create('json-summary').execute(context);
-              console.log('Merged coverage written to ' + process.env.MERGED_OUT_DIR + '/coverage-summary.json');
-            "
-          elif [ -n "$UNIT_COV" ]; then
-            echo "has_merged=false" >> "$GITHUB_OUTPUT"
-            echo "::warning::Integration coverage not found — using unit coverage only"
-          else
-            echo "has_merged=false" >> "$GITHUB_OUTPUT"
-            echo "::warning::No coverage data found"
-          fi
-
       - name: Build report
         if: steps.meta.outputs.skip != 'true'
         id: report
         shell: bash
         env:
           QUALITY: ${{ steps.meta.outputs.quality }}
-          UNIT: ${{ steps.meta.outputs.unit }}
-          INTEG: ${{ steps.meta.outputs.integration }}
-          HAS_MERGED: ${{ steps.coverage.outputs.has_merged }}
+          TESTS: ${{ steps.meta.outputs.tests }}
+          E2E: ${{ steps.meta.outputs.e2e }}
           BASE_FOUND: ${{ steps.base-coverage.outputs.found }}
           BASE_DIR: ${{ steps.base-coverage.outputs.dir }}
           RUN_URL: ${{ github.event.workflow_run.html_url }}
         run: |
           DIR="$RUNNER_TEMP/artifacts"
-          MERGED_DIR="$RUNNER_TEMP/merged-coverage"
 
           # ── Helper: read coverage summary into prefixed vars ──
           read_cov() {
@@ -285,16 +228,10 @@ jobs:
             fi
           }
 
-          # ── Read all coverage reports ──
+          # ── Read coverage reports ──
           UNIT_SUMMARY=$(find "$DIR/test-reports" -name "coverage-summary.json" -type f 2>/dev/null | head -1)
-          INTEG_SUMMARY=$(find "$DIR/integration-reports" -name "coverage-summary.json" -type f 2>/dev/null | head -1)
-          MERGED_SUMMARY="$MERGED_DIR/coverage-summary.json"
 
           read_cov "U" "$UNIT_SUMMARY"
-          HAS_UNIT=$?
-          read_cov "I" "$INTEG_SUMMARY"
-          HAS_INTEG=$?
-          read_cov "M" "$MERGED_SUMMARY"
 
           # ── Read base branch coverage (main) ──
           BASE_SUMMARY=""
@@ -305,36 +242,26 @@ jobs:
 
           # ── Locate test results ──
           RESULTS_FILE=$(find "$DIR/test-reports" -name "test-results.json" -type f 2>/dev/null | head -1)
-          INTEG_RESULTS=$(find "$DIR/integration-reports" -name "integration-results.json" -type f 2>/dev/null | head -1)
+          WEB_RESULTS_FILE=$(find "$DIR/test-reports" -name "web-test-results.json" -type f 2>/dev/null | head -1)
 
-          if [ -n "$RESULTS_FILE" ]; then
-            U_TOTAL=$(jq -r '.numTotalTests' "$RESULTS_FILE" 2>/dev/null || echo 0)
-            U_PASSED=$(jq -r '.numPassedTests' "$RESULTS_FILE" 2>/dev/null || echo 0)
-            U_FAILED=$(jq -r '.numFailedTests' "$RESULTS_FILE" 2>/dev/null || echo 0)
-            U_SKIPPED=$(jq -r '.numPendingTests' "$RESULTS_FILE" 2>/dev/null || echo 0)
-            U_SUITES=$(jq -r '.numTotalTestSuites' "$RESULTS_FILE" 2>/dev/null || echo 0)
-            U_DURATION=$(jq -r '((.testResults | map(.endTime) | max) - (.startTime)) / 1000 | floor' "$RESULTS_FILE" 2>/dev/null || echo 0)
-          else
-            U_TOTAL=0; U_PASSED=0; U_FAILED=0; U_SKIPPED=0; U_SUITES=0; U_DURATION=0
-          fi
+          sum_results() {
+            local file=$1
+            if [ -n "$file" ] && [ -f "$file" ]; then
+              jq -r '"\(.numTotalTests) \(.numPassedTests) \(.numFailedTests) \(.numPendingTests) \(.numTotalTestSuites) \(((.testResults | map(.endTime) | max) - (.startTime)) / 1000 | floor)"' "$file" 2>/dev/null || echo "0 0 0 0 0 0"
+            else
+              echo "0 0 0 0 0 0"
+            fi
+          }
 
-          if [ -n "$INTEG_RESULTS" ]; then
-            I_TOTAL=$(jq -r '.numTotalTests' "$INTEG_RESULTS" 2>/dev/null || echo 0)
-            I_PASSED=$(jq -r '.numPassedTests' "$INTEG_RESULTS" 2>/dev/null || echo 0)
-            I_FAILED=$(jq -r '.numFailedTests' "$INTEG_RESULTS" 2>/dev/null || echo 0)
-            I_SKIPPED=$(jq -r '.numPendingTests' "$INTEG_RESULTS" 2>/dev/null || echo 0)
-            I_SUITES=$(jq -r '.numTotalTestSuites' "$INTEG_RESULTS" 2>/dev/null || echo 0)
-            I_DURATION=$(jq -r '((.testResults | map(.endTime) | max) - (.startTime)) / 1000 | floor' "$INTEG_RESULTS" 2>/dev/null || echo 0)
-          else
-            I_TOTAL=0; I_PASSED=0; I_FAILED=0; I_SKIPPED=0; I_SUITES=0; I_DURATION=0
-          fi
+          read CLI_T CLI_P CLI_F CLI_S CLI_SU CLI_D <<< "$(sum_results "$RESULTS_FILE")"
+          read WEB_T WEB_P WEB_F WEB_S WEB_SU WEB_D <<< "$(sum_results "$WEB_RESULTS_FILE")"
 
-          # ── Sum test results ──
-          TOTAL=$((U_TOTAL + I_TOTAL))
-          PASSED=$((U_PASSED + I_PASSED))
-          FAILED=$((U_FAILED + I_FAILED))
-          SKIPPED=$((U_SKIPPED + I_SKIPPED))
-          SUITES=$((U_SUITES + I_SUITES))
+          TOTAL=$((CLI_T + WEB_T))
+          PASSED=$((CLI_P + WEB_P))
+          FAILED=$((CLI_F + WEB_F))
+          SKIPPED=$((CLI_S + WEB_S))
+          SUITES=$((CLI_SU + WEB_SU))
+          DURATION=$((CLI_D > WEB_D ? CLI_D : WEB_D))
 
           # ── Status helpers ──
           status_icon() {
@@ -346,14 +273,20 @@ jobs:
             esac
           }
 
+          # Validate a value looks like a number (integer or decimal, optional
+          # leading minus).  Returns 1 for anything else — guards against awk
+          # injection when artifact values come from untrusted fork code.
+          is_numeric() { [[ "$1" =~ ^-?[0-9]+(\.[0-9]+)?$ ]]; }
+
           cov_delta() {
             local pct=$1 base=$2
             if [ "$pct" = "N/A" ] || [ "$base" = "N/A" ]; then echo "—"; return; fi
+            if ! is_numeric "$pct" || ! is_numeric "$base"; then echo "—"; return; fi
             local diff
-            diff=$(awk "BEGIN { printf \"%.1f\", $pct - $base }")
-            if [ "$(awk "BEGIN { print ($pct > $base) ? 1 : 0 }")" = "1" ]; then
+            diff=$(awk -v p="$pct" -v b="$base" 'BEGIN { printf "%.1f", p - b }')
+            if [ "$(awk -v p="$pct" -v b="$base" 'BEGIN { print (p > b) ? 1 : 0 }')" = "1" ]; then
               echo "📈 +${diff}"
-            elif [ "$(awk "BEGIN { print ($pct < $base) ? 1 : 0 }")" = "1" ]; then
+            elif [ "$(awk -v p="$pct" -v b="$base" 'BEGIN { print (p < b) ? 1 : 0 }')" = "1" ]; then
               echo "📉 ${diff}"
             else
               echo "＝ ${diff}"
@@ -362,9 +295,9 @@ jobs:
 
           cov_bar() {
             local pct=$1 base=$2
-            if [ "$pct" = "N/A" ]; then echo "—"; return; fi
+            if [ "$pct" = "N/A" ] || ! is_numeric "$pct"; then echo "—"; return; fi
             local filled
-            filled=$(awk "BEGIN { printf \"%d\", $pct / 5 }")
+            filled=$(awk -v p="$pct" 'BEGIN { printf "%d", p / 5 }')
             (( filled < 0 )) && filled=0
             (( filled > 20 )) && filled=20
             local empty=$((20 - filled))
@@ -372,7 +305,7 @@ jobs:
             for ((i=0; i<filled; i++)); do bar+="█"; done
             for ((i=0; i<empty; i++)); do bar+="░"; done
             # Green if >= base (or base unavailable), red if dropped
-            if [ "$base" = "N/A" ] || [ "$(awk "BEGIN { print ($pct >= $base) ? 1 : 0 }")" = "1" ]; then
+            if [ "$base" = "N/A" ] || ! is_numeric "$base" || [ "$(awk -v p="$pct" -v b="$base" 'BEGIN { print (p >= b) ? 1 : 0 }')" = "1" ]; then
               echo "🟢 ${bar}"
             else
               echo "🔴 ${bar}"
@@ -380,7 +313,7 @@ jobs:
           }
 
           # ── Overall status ──
-          if [[ "$QUALITY" == "success" && "$UNIT" == "success" && "$INTEG" == "success" ]]; then
+          if [[ "$QUALITY" == "success" && "$TESTS" == "success" && ("$E2E" == "success" || "$E2E" == "skipped") ]]; then
             OVERALL="✅ **All checks passed**"
           else
             OVERALL="❌ **Some checks failed**"
@@ -398,22 +331,16 @@ jobs:
             echo "| Stage | Status | Details |"
             echo "|-------|--------|---------|"
             echo "| $(status_icon "$QUALITY") Typecheck | \`${QUALITY}\` | tsc --noEmit |"
-            echo "| $(status_icon "$UNIT") Unit Tests | \`${UNIT}\` | 3 platforms |"
-            echo "| $(status_icon "$INTEG") Integration | \`${INTEG}\` | 3 OS x 4 groups = 12 jobs |"
+            echo "| $(status_icon "$TESTS") Tests | \`${TESTS}\` | unit tests, 3 platforms |"
+            echo "| $(status_icon "$E2E") E2E | \`${E2E}\` | gitnexus-web changes only |"
             echo ""
 
             if [ "$TOTAL" -gt 0 ] 2>/dev/null; then
               echo "### Test Results"
               echo ""
-              echo "| Suite | Tests | Passed | Failed | Skipped | Duration |"
-              echo "|-------|-------|--------|--------|---------|----------|"
-              if [ "$U_TOTAL" -gt 0 ] 2>/dev/null; then
-                echo "| Unit | ${U_TOTAL} | ${U_PASSED} | ${U_FAILED} | ${U_SKIPPED} | ${U_DURATION}s |"
-              fi
-              if [ "$I_TOTAL" -gt 0 ] 2>/dev/null; then
-                echo "| Integration | ${I_TOTAL} | ${I_PASSED} | ${I_FAILED} | ${I_SKIPPED} | ${I_DURATION}s |"
-              fi
-              echo "| **Total** | **${TOTAL}** | **${PASSED}** | **${FAILED}** | **${SKIPPED}** | **$((U_DURATION + I_DURATION))s** |"
+              echo "| Tests | Passed | Failed | Skipped | Duration |"
+              echo "|-------|--------|--------|---------|----------|"
+              echo "| ${TOTAL} | ${PASSED} | ${FAILED} | ${SKIPPED} | ${DURATION}s |"
               echo ""
 
               if [ "$FAILED" = "0" ]; then
@@ -426,27 +353,16 @@ jobs:
                 echo "<details>"
                 echo "<summary>${SKIPPED} test(s) skipped — expand for details</summary>"
                 echo ""
-                # Extract skipped test names from integration results
-                if [ -n "$INTEG_RESULTS" ] && [ "$I_SKIPPED" -gt 0 ] 2>/dev/null; then
-                  echo "**Integration:**"
-                  jq -r '
-                    .testResults[]
-                    | .assertionResults[]?
-                    | select(.status == "pending" or .status == "skipped")
-                    | "- \(.ancestorTitles | join(" > ")) > \(.title)"
-                  ' "$INTEG_RESULTS" 2>/dev/null || echo "- _(unable to parse skipped test details)_"
-                fi
-                # Extract skipped test names from unit results
-                if [ -n "$RESULTS_FILE" ] && [ "$U_SKIPPED" -gt 0 ] 2>/dev/null; then
-                  echo ""
-                  echo "**Unit:**"
-                  jq -r '
-                    .testResults[]
-                    | .assertionResults[]?
-                    | select(.status == "pending" or .status == "skipped")
-                    | "- \(.ancestorTitles | join(" > ")) > \(.title)"
-                  ' "$RESULTS_FILE" 2>/dev/null || echo "- _(unable to parse skipped test details)_"
-                fi
+                for rf in "$RESULTS_FILE" "$WEB_RESULTS_FILE"; do
+                  if [ -n "$rf" ] && [ -f "$rf" ]; then
+                    jq -r '
+                      .testResults[]
+                      | .assertionResults[]?
+                      | select(.status == "pending" or .status == "skipped")
+                      | "- \(.ancestorTitles | join(" > ")) > \(.title)"
+                    ' "$rf" 2>/dev/null || true
+                  fi
+                done
                 echo ""
                 echo "</details>"
               fi
@@ -469,35 +385,10 @@ jobs:
               echo ""
             }
 
-            if [ "$M_STMTS" != "N/A" ]; then
+            if [ "$U_STMTS" != "N/A" ]; then
               echo "### Code Coverage"
               echo ""
-              cov_table "Combined (Unit + Integration)" \
-                "$M_STMTS" "$M_BRANCH" "$M_FUNCS" "$M_LINES" \
-                "$M_STMTS_COV" "$M_BRANCH_COV" "$M_FUNCS_COV" "$M_LINES_COV" \
-                "$B_STMTS" "$B_BRANCH" "$B_FUNCS" "$B_LINES"
-
-              echo "<details>"
-              echo "<summary>Coverage breakdown by test suite</summary>"
-              echo ""
-              if [ "$U_STMTS" != "N/A" ]; then
-                cov_table "Unit Tests" \
-                  "$U_STMTS" "$U_BRANCH" "$U_FUNCS" "$U_LINES" \
-                  "$U_STMTS_COV" "$U_BRANCH_COV" "$U_FUNCS_COV" "$U_LINES_COV" \
-                  "$B_STMTS" "$B_BRANCH" "$B_FUNCS" "$B_LINES"
-              fi
-              if [ "$I_STMTS" != "N/A" ]; then
-                cov_table "Integration Tests" \
-                  "$I_STMTS" "$I_BRANCH" "$I_FUNCS" "$I_LINES" \
-                  "$I_STMTS_COV" "$I_BRANCH_COV" "$I_FUNCS_COV" "$I_LINES_COV" \
-                  "$B_STMTS" "$B_BRANCH" "$B_FUNCS" "$B_LINES"
-              fi
-              echo "</details>"
-              echo ""
-            elif [ "$U_STMTS" != "N/A" ]; then
-              echo "### Code Coverage (Unit only)"
-              echo ""
-              cov_table "Unit Tests" \
+              cov_table "Tests" \
                 "$U_STMTS" "$U_BRANCH" "$U_FUNCS" "$U_LINES" \
                 "$U_STMTS_COV" "$U_BRANCH_COV" "$U_FUNCS_COV" "$U_LINES_COV" \
                 "$B_STMTS" "$B_BRANCH" "$B_FUNCS" "$B_LINES"

.github/workflows/ci-tests.yml

@@ -1,20 +1,22 @@
-name: Unit Tests
+name: Tests
 
 on:
   workflow_call:
 
 jobs:
-  unit-tests:
-    name: unit (ubuntu / coverage)
+  tests:
+    name: ubuntu / coverage
     runs-on: ubuntu-latest
-    timeout-minutes: 15
+    timeout-minutes: 25
     steps:
       - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
       - uses: ./.github/actions/setup-gitnexus
+        with:
+          build: 'true'
 
-      - name: Run unit tests with coverage
+      - name: Run all tests with coverage
         run: >-
-          npx vitest run test/unit
+          npx vitest run
           --reporter=default
           --reporter=json
           --outputFile=test-results.json
@@ -26,6 +28,19 @@ jobs:
           --coverage.reportOnFailure=true
         working-directory: gitnexus
 
+      # gitnexus-shared already built by setup-gitnexus action above
+      - name: Install gitnexus-web dependencies
+        run: npm ci
+        working-directory: gitnexus-web
+
+      - name: Run gitnexus-web unit tests
+        run: >-
+          npx vitest run
+          --reporter=default
+          --reporter=json
+          --outputFile=web-test-results.json
+        working-directory: gitnexus-web
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
@@ -35,19 +50,22 @@ jobs:
             gitnexus/coverage/coverage-summary.json
             gitnexus/coverage/coverage-final.json
             gitnexus/test-results.json
+            gitnexus-web/web-test-results.json
           retention-days: 5
 
   cross-platform:
-    name: unit (${{ matrix.os }})
+    name: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
         # Ubuntu already covered by the coverage job above
         os: [windows-latest, macos-latest]
     runs-on: ${{ matrix.os }}
-    timeout-minutes: 15
+    timeout-minutes: 25
     steps:
       - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
       - uses: ./.github/actions/setup-gitnexus
-      - run: npx vitest run test/unit
+        with:
+          build: 'true'
+      - run: npx vitest run
         working-directory: gitnexus

.github/workflows/ci.yml

@@ -16,8 +16,8 @@ concurrency:
 # ── Reusable workflow orchestration ─────────────────────────────────
 # Each concern lives in its own workflow file for maintainability:
 #   ci-quality.yml       — typecheck (tsc --noEmit)
-#   ci-unit-tests.yml    — unit tests with coverage + cross-platform
-#   ci-integration.yml   — integration test matrix (3 OS x 4 groups)
+#   ci-tests.yml         — unit + integration tests with coverage + cross-platform
+#   ci-e2e.yml           — E2E tests (only when gitnexus-web/ changes)
 #
 # Shared setup is DRY via .github/actions/setup-gitnexus composite action.
 
@@ -27,15 +27,13 @@ jobs:
     permissions:
       contents: read
 
-  unit-tests:
-    uses: ./.github/workflows/ci-unit-tests.yml
+  tests:
+    uses: ./.github/workflows/ci-tests.yml
     permissions:
       contents: read
 
-  integration:
-    uses: ./.github/workflows/ci-integration.yml
-    with:
-      collect-coverage: ${{ github.event_name == 'pull_request' }}
+  e2e:
+    uses: ./.github/workflows/ci-e2e.yml
     permissions:
       contents: read
 
@@ -47,7 +45,7 @@ jobs:
   save-pr-meta:
     name: Save PR Metadata
     if: always() && github.event_name == 'pull_request'
-    needs: [quality, unit-tests, integration]
+    needs: [quality, tests, e2e]
     runs-on: ubuntu-latest
     timeout-minutes: 5
     steps:
@@ -56,14 +54,24 @@ jobs:
         env:
           PR_NUMBER: ${{ github.event.number }}
           QUALITY: ${{ needs.quality.result }}
-          UNIT: ${{ needs.unit-tests.result }}
-          INTEG: ${{ needs.integration.result }}
+          TESTS: ${{ needs.tests.result }}
+          E2E: ${{ needs.e2e.result }}
         run: |
           mkdir -p pr-meta
           echo "$PR_NUMBER"  > pr-meta/pr_number
           echo "$QUALITY"    > pr-meta/quality_result
-          echo "$UNIT"       > pr-meta/unit_result
-          echo "$INTEG"      > pr-meta/integration_result
+          echo "$TESTS"      > pr-meta/tests_result
+          echo "$E2E"        > pr-meta/e2e_result
+          # TODO(post-merge): remove backward-compat copies once ci-report.yml
+          # on main reads underscore names.
+          # Backward-compat: ci-report.yml on main still reads hyphenated
+          # names.  workflow_run always executes from the default branch, so
+          # the main-branch reader won't find the underscore variants until
+          # this PR is merged.  Write both until then.
+          cp pr-meta/pr_number       pr-meta/pr-number
+          cp pr-meta/quality_result  pr-meta/quality-result
+          cp pr-meta/tests_result    pr-meta/tests-result
+          cp pr-meta/e2e_result      pr-meta/e2e-result
 
       - name: Upload PR metadata
         uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
@@ -76,7 +84,7 @@ jobs:
   # Single required check for branch protection.
   ci-status:
     name: CI Gate
-    needs: [quality, unit-tests, integration]
+    needs: [quality, tests, e2e]
     if: always()
     runs-on: ubuntu-latest
     timeout-minutes: 5
@@ -85,15 +93,18 @@ jobs:
         shell: bash
         env:
           QUALITY: ${{ needs.quality.result }}
-          UNIT: ${{ needs.unit-tests.result }}
-          INTEG: ${{ needs.integration.result }}
+          TESTS: ${{ needs.tests.result }}
+          E2E: ${{ needs.e2e.result }}
         run: |
           echo "Quality:     $QUALITY"
-          echo "Unit Tests:  $UNIT"
-          echo "Integration: $INTEG"
+          echo "Tests:       $TESTS"
+          echo "E2E:         $E2E"
           if [[ "$QUALITY" != "success" ]] ||
-             [[ "$UNIT" != "success" ]] ||
-             [[ "$INTEG" != "success" ]]; then
-            echo "::error::One or more CI jobs failed"
+             [[ "$TESTS" != "success" ]]; then
+            echo "::error::Quality or test jobs failed"
+            exit 1
+          fi
+          if [[ "$E2E" != "success" && "$E2E" != "skipped" ]]; then
+            echo "::error::E2E job failed"
             exit 1
           fi

.github/workflows/claude-code-review.yml

@@ -2,8 +2,9 @@ name: Claude Code Review
 
 # Uses pull_request_target so the workflow runs as defined on the default branch,
 # which allows access to secrets for posting review comments on fork PRs.
-# SECURITY: The checkout below uses the PR head SHA to review the correct code.
-# The claude-code-action sandboxes execution — it does NOT run arbitrary code
+# SECURITY: The checkout pins the fork's HEAD SHA (not the branch name) to
+# prevent TOCTOU races (force-push between trigger and checkout). The
+# claude-code-action sandboxes execution — it does NOT run arbitrary code
 # from the checked-out source.
 
 on:
@@ -15,8 +16,7 @@ on:
   issue_comment:
     types: [created]
 
-# Serialize per-PR so concurrent @claude comments don't race on the
-# temporary fork branch push/delete.
+# Serialize per-PR to avoid racing review comments.
 concurrency:
   group: claude-review-${{ github.event.issue.number || github.event.pull_request.number }}
   cancel-in-progress: false
@@ -47,13 +47,13 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 30
     permissions:
-      contents: write       # needed to create fork branch ref via API
+      contents: read
       pull-requests: write
       issues: read
       id-token: write
 
     steps:
-      # For issue_comment triggers, resolve the PR number, head SHA, and branch name
+      # For issue_comment triggers, resolve the PR number, head SHA, and fork repo
       - name: Resolve PR context
         id: pr
         uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7
@@ -72,50 +72,24 @@ jobs:
             }
             core.setOutput('number', pr.number);
             core.setOutput('sha', pr.head.sha);
+            core.setOutput('repo', pr.head.repo.full_name);
             core.setOutput('branch', pr.head.ref);
-            core.setOutput('is_fork', String(pr.head.repo.full_name !== pr.base.repo.full_name));
 
       - name: Checkout PR head
         uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
         with:
+          repository: ${{ steps.pr.outputs.repo }}
           ref: ${{ steps.pr.outputs.sha }}
           fetch-depth: 1
 
-      # claude-code-action fetches branches by name from origin, which fails
-      # for fork PRs. Create a temporary branch ref via the API so the action
-      # can find it. Using the API (not git push) avoids the GITHUB_TOKEN
-      # restriction that blocks pushing commits containing workflow file changes.
-      - name: Create fork branch ref on origin
-        id: push-fork
-        if: steps.pr.outputs.is_fork == 'true'
-        env:
-          FORK_BRANCH: ${{ steps.pr.outputs.branch }}
-          FORK_SHA: ${{ steps.pr.outputs.sha }}
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          gh api "repos/${{ github.repository }}/git/refs" \
-            --method POST \
-            -f ref="refs/heads/$FORK_BRANCH" \
-            -f sha="$FORK_SHA" \
-          || gh api "repos/${{ github.repository }}/git/refs/heads/$FORK_BRANCH" \
-            --method PATCH \
-            -f sha="$FORK_SHA" \
-            -F force=true
-
       - name: Run Claude Code Review
         id: claude-review
         uses: anthropics/claude-code-action@9469d113c6afd29550c402740f22d1a97dd1209b # v1
         with:
           claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          allowed_non_write_users: '*'
+          show_full_output: true
           plugin_marketplaces: 'https://github.com/anthropics/claude-code.git'
           plugins: 'code-review@claude-code-plugins'
           prompt: '/code-review:code-review ${{ github.repository }}/pull/${{ steps.pr.outputs.number }}'
-
-      # Clean up the temporary branch ref we created for fork PRs.
-      # Only delete if the create step actually succeeded.
-      - name: Delete fork branch ref from origin
-        if: always() && steps.push-fork.outcome == 'success'
-        env:
-          FORK_BRANCH: ${{ steps.pr.outputs.branch }}
-          GH_TOKEN: ${{ github.token }}
-        run: gh api "repos/${{ github.repository }}/git/refs/heads/$FORK_BRANCH" --method DELETE || true

.github/workflows/claude.yml

@@ -10,8 +10,7 @@ on:
   pull_request_review:
     types: [submitted]
 
-# Serialize per-PR so concurrent @claude comments don't race on the
-# temporary fork branch push/delete.
+# Serialize per-PR/issue to avoid racing comments.
 concurrency:
   group: claude-code-${{ github.event.issue.number || github.event.pull_request.number || github.event.issue.id }}
   cancel-in-progress: false
@@ -19,21 +18,44 @@ concurrency:
 jobs:
   claude:
     if: |
-      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
-      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
-      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
-      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+      (
+        github.event_name == 'issue_comment' &&
+        contains(github.event.comment.body, '@claude') &&
+        (github.event.comment.author_association == 'OWNER' ||
+         github.event.comment.author_association == 'MEMBER' ||
+         github.event.comment.author_association == 'COLLABORATOR')
+      ) ||
+      (
+        github.event_name == 'pull_request_review_comment' &&
+        contains(github.event.comment.body, '@claude') &&
+        (github.event.comment.author_association == 'OWNER' ||
+         github.event.comment.author_association == 'MEMBER' ||
+         github.event.comment.author_association == 'COLLABORATOR')
+      ) ||
+      (
+        github.event_name == 'pull_request_review' &&
+        contains(github.event.review.body, '@claude') &&
+        (github.event.review.author_association == 'OWNER' ||
+         github.event.review.author_association == 'MEMBER' ||
+         github.event.review.author_association == 'COLLABORATOR')
+      ) ||
+      (
+        github.event_name == 'issues' &&
+        (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')) &&
+        (github.event.issue.author_association == 'OWNER' ||
+         github.event.issue.author_association == 'MEMBER' ||
+         github.event.issue.author_association == 'COLLABORATOR')
+      )
     runs-on: ubuntu-latest
     timeout-minutes: 30
     permissions:
-      contents: write       # needed to create fork branch ref via API
+      contents: read
       pull-requests: write
       issues: write
       id-token: write
-      actions: read         # required for Claude to read CI results on PRs
+      actions: read # required for Claude to read CI results on PRs
     steps:
-      # For PR-related triggers, resolve fork context so we can create a
-      # temporary branch ref (claude-code-action fetches by branch name).
+      # For PR-related triggers, resolve the fork repo so we can checkout correctly.
       - name: Resolve PR context
         id: pr
         uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7
@@ -51,7 +73,6 @@ jobs:
 
             if (!prNumber) {
               core.setOutput('is_pr', 'false');
-              core.setOutput('is_fork', 'false');
               return;
             }
 
@@ -61,55 +82,29 @@ jobs:
               pull_number: prNumber,
             });
             const pr = resp.data;
-            const isFork = pr.head.repo.full_name !== pr.base.repo.full_name;
 
             core.setOutput('is_pr', 'true');
-            core.setOutput('is_fork', String(isFork));
-            core.setOutput('branch', pr.head.ref);
+            core.setOutput('number', String(prNumber));
             core.setOutput('sha', pr.head.sha);
+            core.setOutput('repo', pr.head.repo.full_name);
+            core.setOutput('branch', pr.head.ref);
 
       - name: Checkout repository
         uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
         with:
-          ref: ${{ steps.pr.outputs.is_fork == 'true' && steps.pr.outputs.sha || '' }}
+          repository: ${{ steps.pr.outputs.is_pr == 'true' && steps.pr.outputs.repo || github.repository }}
+          ref: ${{ steps.pr.outputs.is_pr == 'true' && steps.pr.outputs.sha || '' }}
           fetch-depth: 1
 
-      # claude-code-action fetches branches by name from origin, which fails
-      # for fork PRs. Create a temporary branch ref via the API so the action
-      # can find it. Using the API (not git push) avoids the GITHUB_TOKEN
-      # restriction that blocks pushing commits containing workflow file changes.
-      - name: Create fork branch ref on origin
-        id: push-fork
-        if: steps.pr.outputs.is_fork == 'true'
-        env:
-          FORK_BRANCH: ${{ steps.pr.outputs.branch }}
-          FORK_SHA: ${{ steps.pr.outputs.sha }}
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          gh api "repos/${{ github.repository }}/git/refs" \
-            --method POST \
-            -f ref="refs/heads/$FORK_BRANCH" \
-            -f sha="$FORK_SHA" \
-          || gh api "repos/${{ github.repository }}/git/refs/heads/$FORK_BRANCH" \
-            --method PATCH \
-            -f sha="$FORK_SHA" \
-            -F force=true
-
       - name: Run Claude Code
         id: claude
         uses: anthropics/claude-code-action@9469d113c6afd29550c402740f22d1a97dd1209b # v1
         with:
           claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          allowed_non_write_users: '*'
+          show_full_output: true
 
           # This is an optional setting that allows Claude to read CI results on PRs
           additional_permissions: |
             actions: read
-
-      # Clean up the temporary branch ref we created for fork PRs.
-      # Only delete if the create step actually succeeded.
-      - name: Delete fork branch ref from origin
-        if: always() && steps.push-fork.outcome == 'success'
-        env:
-          FORK_BRANCH: ${{ steps.pr.outputs.branch }}
-          GH_TOKEN: ${{ github.token }}
-        run: gh api "repos/${{ github.repository }}/git/refs/heads/$FORK_BRANCH" --method DELETE || true

.github/workflows/pr-description-check.yml

@@ -0,0 +1,94 @@
+name: PR Description Check
+
+on:
+  pull_request:
+    types: [opened, edited, reopened]
+    branches: [main]
+
+permissions:
+  pull-requests: write
+
+concurrency:
+  group: pr-desc-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  check-description:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - name: Check PR description quality
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        with:
+          script: |
+            const MIN_BODY_LENGTH = 50;
+            const LABEL = 'needs-description';
+
+            const pr = context.payload.pull_request;
+            const body = (pr.body || '').trim();
+            const owner = context.repo.owner;
+            const repo = context.repo.repo;
+            const number = pr.number;
+
+            const hasLabel = pr.labels.some(l => l.name === LABEL);
+
+            if (body.length < MIN_BODY_LENGTH) {
+              // Add label if not already present
+              if (!hasLabel) {
+                await github.rest.issues.addLabels({
+                  owner, repo, issue_number: number,
+                  labels: [LABEL],
+                });
+              }
+
+              // Post or update a comment
+              const marker = '<!-- pr-desc-check -->';
+              const message = [
+                marker,
+                `### PR description is too short`,
+                '',
+                `This PR's description is **${body.length}** characters, ` +
+                `but the minimum is **${MIN_BODY_LENGTH}**.`,
+                '',
+                'Please update the PR description to explain:',
+                '- **What** this PR changes',
+                '- **Why** the change is needed',
+                '',
+                'Use the PR template as a guide. This check will re-run when you edit the description.',
+              ].join('\n');
+
+              // Find existing bot comment to update (avoid spam)
+              const comments = await github.rest.issues.listComments({
+                owner, repo, issue_number: number,
+              });
+              const existing = comments.data.find(c =>
+                c.body && c.body.includes(marker)
+              );
+
+              if (existing) {
+                await github.rest.issues.updateComment({
+                  owner, repo, comment_id: existing.id,
+                  body: message,
+                });
+              } else {
+                await github.rest.issues.createComment({
+                  owner, repo, issue_number: number,
+                  body: message,
+                });
+              }
+
+              core.setFailed(
+                `PR description is ${body.length} chars (minimum: ${MIN_BODY_LENGTH})`
+              );
+            } else {
+              // Description is acceptable — remove the label if present
+              if (hasLabel) {
+                await github.rest.issues.removeLabel({
+                  owner, repo, issue_number: number,
+                  name: LABEL,
+                }).catch(() => {});
+                // .catch: label may have been removed manually
+              }
+
+              core.info(`PR description OK (${body.length} chars)`);
+            }

.github/workflows/publish.yml

@@ -12,6 +12,7 @@ jobs:
     uses: ./.github/workflows/ci.yml
     permissions:
       contents: read
+      actions: read
       pull-requests: write
 
   publish:
@@ -29,6 +30,10 @@ jobs:
           registry-url: https://registry.npmjs.org
           cache: npm
           cache-dependency-path: gitnexus/package-lock.json
+      - name: Build gitnexus-shared
+        run: npm install && npm run build
+        working-directory: gitnexus-shared
+
       - run: npm ci
         working-directory: gitnexus
 
@@ -62,7 +67,22 @@ jobs:
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
 
+      - name: Extract release notes from CHANGELOG
+        id: changelog
+        shell: bash
+        run: |
+          VERSION="${GITHUB_REF#refs/tags/v}"
+          NOTES=$(awk "/^## \\[$VERSION\\]/{found=1; next} /^## \\[/{if(found) exit} found" gitnexus/CHANGELOG.md)
+          if [ -z "$NOTES" ]; then
+            echo "::warning::No CHANGELOG entry found for v$VERSION, falling back to auto-generated notes"
+            echo "fallback=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "$NOTES" > /tmp/release-notes.md
+            echo "fallback=false" >> "$GITHUB_OUTPUT"
+          fi
+
       - name: Create GitHub Release
         uses: softprops/action-gh-release@a06a81a03ee405af7f2048a818ed3f03bbf83c7b # v2
         with:
-          generate_release_notes: true
+          body_path: ${{ steps.changelog.outputs.fallback == 'false' && '/tmp/release-notes.md' || '' }}
+          generate_release_notes: ${{ steps.changelog.outputs.fallback == 'true' }}

.github/workflows/triage-sweep.yml

@@ -0,0 +1,103 @@
+name: Triage Sweep
+
+on:
+  workflow_dispatch:
+    inputs:
+      iqr_multiplier:
+        description: >-
+          IQR multiplier for outlier cutoff.
+          cutoff = Q75 + multiplier * IQR.
+          Higher = fewer outliers flagged.
+        type: number
+        default: 3.0
+      max_outlier_pct:
+        description: >-
+          Maximum fraction of items that can be flagged as outliers (0-1).
+          Hard cap to prevent over-flagging.
+        type: number
+        default: 0.05
+      contamination:
+        description: >-
+          Expected fraction of outliers in the data (0-0.5).
+          Controls how aggressively EllipticEnvelope downweights extremes.
+        type: number
+        default: 0.1
+      cosine_threshold:
+        description: >-
+          Cosine similarity threshold for duplicate detection.
+          Pairs with similarity above this are flagged as potential duplicates.
+          Higher = only very similar pairs flagged.
+        type: number
+        default: 0.92
+      max_items:
+        description: >-
+          Maximum number of open issues + PRs to process.
+          Hard cap to prevent runaway costs on very large repos.
+        type: number
+        default: 500
+      dry_run:
+        description: >-
+          Check this to only log results to the workflow summary.
+          Uncheck to create a GitHub issue with the report and apply labels.
+        type: boolean
+        default: false
+
+permissions:
+  contents: read
+  issues: write
+  pull-requests: write
+
+concurrency:
+  group: triage-sweep
+  cancel-in-progress: true
+
+jobs:
+  sweep:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        with:
+          sparse-checkout: .github/scripts/triage
+          sparse-checkout-cone-mode: false
+          fetch-depth: 1
+
+      - name: Set up Python
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
+        with:
+          python-version: '3.12'
+          cache: pip
+          cache-dependency-path: .github/scripts/triage/requirements.txt
+
+      - name: Install dependencies
+        run: pip install -r .github/scripts/triage/requirements.txt
+
+      - name: Cache FastEmbed model weights
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5
+        with:
+          path: ${{ github.workspace }}/.fastembed_cache
+          key: fastembed-bge-small-en-v1.5
+
+      - name: Run triage sweep
+        id: sweep
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+          FASTEMBED_CACHE_PATH: ${{ github.workspace }}/.fastembed_cache
+          INPUT_IQR_MULTIPLIER: ${{ inputs.iqr_multiplier }}
+          INPUT_MAX_OUTLIER_PCT: ${{ inputs.max_outlier_pct }}
+          INPUT_CONTAMINATION: ${{ inputs.contamination }}
+          INPUT_COSINE_THRESHOLD: ${{ inputs.cosine_threshold }}
+          INPUT_MAX_ITEMS: ${{ inputs.max_items }}
+          INPUT_DRY_RUN: ${{ inputs.dry_run }}
+        run: python .github/scripts/triage/sweep.py
+
+      - name: Post summary
+        if: always()
+        run: |
+          if [ -f /tmp/triage-report.md ]; then
+            cat /tmp/triage-report.md >> "$GITHUB_STEP_SUMMARY"
+          else
+            echo "No report generated." >> "$GITHUB_STEP_SUMMARY"
+          fi

.gitignore

@@ -33,6 +33,8 @@ coverage/
 
 # Misc
 *.local
+HANDOFF.md
+HANDOFF*.md
 
 .vercel
 
@@ -57,6 +59,14 @@ assets/
 # Generated files (should not be indexed)
 repomix-output*
 
+# Playwright artifacts
+gitnexus-web/playwright-report/
+gitnexus-web/test-results/
+
+# Python test artifacts
+eval/.coverage
+eval/.hypothesis/
+
 # Design docs (local only)
 docs/plans/
 
@@ -67,4 +77,22 @@ gitnexus/test/fixtures/mini-repo/.gitignore
 # Ignore csharp generated obj and bin folders
 gitnexus/test/fixtures/lang-resolution/**/obj
 gitnexus/test/fixtures/lang-resolution/**/bin
-GitNexus.sln
+GitNexus.sln
+# Git worktrees
+.worktrees/
+
+/github/scripts/triage/__pycache__/
+
+.claude-flow/
+
+.claude/agents/
+.claude/commands/
+.claude/helpers
+.claude/skills/
+!.claude/skills/gitnexus/
+
+.history/
+
+.swarm/
+
+local_docs/

.history/gitnexus/vitest.config_20260317171253.ts

@@ -0,0 +1,33 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globalSetup: ['test/global-setup.ts'],
+    include: ['test/**/*.test.ts'],
+    testTimeout: 30000,
+    hookTimeout: 120000,
+    pool: 'forks',
+    globals: true,
+    setupFiles: ['test/setup.ts'],
+    teardownTimeout: 3000,
+    dangerouslyIgnoreUnhandledErrors: true, // LadybugDB N-API destructor segfaults on fork exit — not a test failure
+    coverage: {
+      provider: 'v8',
+      include: ['src/**/*.ts'],
+      exclude: [
+        'src/cli/index.ts',          // CLI entry point (commander wiring)
+        'src/server/**',              // HTTP server (requires network)
+        'src/core/wiki/**',           // Wiki generation (requires LLM)
+      ],
+      // Auto-ratchet: vitest bumps thresholds when coverage exceeds them.
+      // CI will fail if a PR drops below these floors.
+      thresholds: {
+        statements: 26,
+        branches: 23,
+        functions: 28,
+        lines: 27,
+        autoUpdate: true,
+      },
+    },
+  },
+});

.husky/pre-commit

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Pre-commit hook: format staged files + typecheck.
+# Tests run in CI (ci-tests.yml), not here.
+# Skip with: git commit --no-verify
+
+ROOT="$(git rev-parse --show-toplevel)"
+
+# 1. Format staged files with prettier via lint-staged
+echo "pre-commit: formatting staged files..."
+"$ROOT/node_modules/.bin/lint-staged" || exit 1
+
+# 2. Typecheck changed packages
+WEB_CHANGED=$(git diff --cached --name-only -- 'gitnexus-web/' | head -1)
+CLI_CHANGED=$(git diff --cached --name-only -- 'gitnexus/' | head -1)
+
+if [ -n "$WEB_CHANGED" ]; then
+  echo "pre-commit: typechecking gitnexus-web (tsc -b)..."
+  cd "$ROOT/gitnexus-web" && ./node_modules/.bin/tsc -b --noEmit || exit 1
+fi
+
+if [ -n "$CLI_CHANGED" ]; then
+  echo "pre-commit: typechecking gitnexus..."
+  cd "$ROOT/gitnexus" && ./node_modules/.bin/tsc --noEmit || exit 1
+fi
+
+echo "pre-commit: all checks passed"

.prettierignore

@@ -0,0 +1,16 @@
+dist/
+coverage/
+gitnexus/vendor/
+gitnexus/test/fixtures/
+gitnexus-web/playwright-report/
+gitnexus-web/test-results/
+*.d.ts
+*.snap
+*.wasm
+*.md
+.gitnexus/
+.vercel/
+.claude-flow/
+.swarm/
+assets/
+repomix-output*

.prettierrc

@@ -0,0 +1,10 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "trailingComma": "all",
+  "printWidth": 100,
+  "tabWidth": 2,
+  "endOfLine": "lf",
+  "plugins": ["prettier-plugin-tailwindcss"],
+  "tailwindStylesheet": "./gitnexus-web/src/index.css"
+}

AGENTS.md

@@ -1,7 +1,69 @@
+<!-- version: 1.2.0 -->
+<!--
+  Metadata: version, last reviewed, scope, model policy, reference docs, changelog.
+  Last updated: 2026-03-22
+-->
+
+Last reviewed: 2026-03-24
+
+**Project:** GitNexus · **Environment:** dev · **Maintainer:** repository maintainers (see GitHub)
+
+This file uses a standard agent header (version, scope, model policy, reference docs, changelog), adapted for this **TypeScript/JavaScript monorepo**.
+
+## Scope
+
+| | |
+|--|--|
+| **Reads** | Repository tree as needed for the task: `gitnexus/`, `gitnexus-web/`, `eval/`, plugin packages, `.github/`, `.gitnexus/` when present, and docs. |
+| **Writes** | Only paths required for the requested change; keep diffs minimal. Update lockfiles when dependencies change. |
+| **Executes** | `npm`, `npx`, `node` under `gitnexus/` and `gitnexus-web/`; `uv run` for Python under `eval/` when applicable; shell utilities for documented CI/dev workflows. |
+| **Off-limits** | User secrets (e.g. real `.env`), production deployment credentials, unrelated repositories, destructive git history operations without explicit human confirmation. |
+
+## Model Configuration
+
+- **Primary:** Pin in **Cursor** (Settings → model). Use a **named** model (e.g. GPT-5.2, Claude Sonnet 4.x). Avoid relying on **Auto** when reproducibility or audit trail matters.
+- **Fallback:** As configured in Cursor or your organization (do not encode `latest` or wildcards in automation configs).
+- **Notes:** The open-source GitNexus CLI indexer does not call an LLM. Optional Nexus AI in the web UI uses end-user provider keys and models.
+
+## Execution Sequence (complex tasks)
+
+Long sessions dilute instructions. For **multi-step** work, state up front:
+
+1. Which rules in this file and **[GUARDRAILS.md](GUARDRAILS.md)** apply (and any relevant Signs).
+2. Current **Scope** boundaries (Reads / Writes / Off-limits).
+3. Which **validation commands** you will run (e.g. `cd gitnexus && npm test`, `npx tsc --noEmit`).
+
+On very long threads, the human may add *“Remember: apply all AGENTS.md rules”* to re-weight rule tokens against context dilution.
+
+## Claude Code hooks
+
+Hooks enforce gates that prompts cannot. In **Claude Code**, **PreToolUse** hooks can block tools such as `git_commit` until checks pass. Adapt to this repo: e.g. `cd gitnexus && npm test` before commit.
+
+## Context budget (Cursor / standards)
+
+Generic “core standards” playbooks are often long and stack-specific. For this monorepo, commands and gotchas live under **Cursor Cloud specific instructions** below and in **[CONTRIBUTING.md](CONTRIBUTING.md)**. If always-on rules grow, split domain rules into **`.cursor/rules/*.mdc`** (globs). **Cursor:** project-wide rules live in **`.cursor/index.mdc`** (YAML frontmatter with `alwaysApply: true`). **Claude Code:** optionally load a **`STANDARDS.md`** only when needed (e.g. *“When writing new code, read STANDARDS.md”*) to save context.
+
+## Reference Documentation
+
+- **This repository:** **[ARCHITECTURE.md](ARCHITECTURE.md)**, **[CONTRIBUTING.md](CONTRIBUTING.md)**, **[GUARDRAILS.md](GUARDRAILS.md)**.
+- **Cursor:** `.cursor/index.mdc` (always-on rules); optional `.cursor/rules/*.mdc` (glob-scoped). Legacy `.cursorrules` is deprecated — see `.cursor/index.mdc`.
+- **Optional local files:** `NOTES.md` (short vendor-neutral project snapshot). For handoffs, keep notes local (e.g., a scratch file outside the repo) rather than committing `HANDOFF.md`.
+- **GitNexus:** skills under `.claude/skills/gitnexus/`; machine-oriented rules in the `gitnexus:start` … `gitnexus:end` block below.
+
+## Changelog
+
+| Date | Version | Change |
+|------|---------|--------|
+| 2026-03-24 | 1.2.0 | Fixed gitnexus:start block duplication (was inlined in Reference Docs bullet). |
+| 2026-03-23 | 1.1.0 | Updated agent instructions (sections, references, Cursor layout). |
+| 2026-03-22 | 1.0.0 | Added structured agent header and changelog. |
+
+---
+
 <!-- gitnexus:start -->
 # GitNexus — Code Intelligence
 
-This project is indexed by GitNexus as **GitNexus** (1999 symbols, 4681 relationships, 149 execution flows). Use the GitNexus MCP tools to understand code, assess impact, and navigate safely.
+This project is indexed by GitNexus as **GitNexus**. Use the GitNexus MCP tools to understand code, assess impact, and navigate safely. For current symbol stats, run `npx gitnexus analyze` and inspect `.gitnexus/meta.json`.
 
 > If any GitNexus tool warns the index is stale, run `npx gitnexus analyze` in terminal first.
 
@@ -99,3 +161,44 @@ To check whether embeddings exist, inspect `.gitnexus/meta.json` — the `stats.
 | Index, status, clean, wiki CLI commands | `.claude/skills/gitnexus/gitnexus-cli/SKILL.md` |
 
 <!-- gitnexus:end -->
+
+## Cursor Cloud specific instructions
+
+### Repository structure
+
+This is a monorepo with two main products and supporting config packages:
+
+| Component | Path | Purpose |
+|-----------|------|---------|
+| **GitNexus CLI/Core** | `gitnexus/` | Main product — TypeScript CLI, indexing pipeline, MCP server. Published to npm. |
+| **GitNexus Web UI** | `gitnexus-web/` | React/Vite browser app — graph explorer + AI chat. Runs entirely in WASM. |
+| Claude Plugin | `gitnexus-claude-plugin/` | Static config for Claude marketplace (no build). |
+| Cursor Integration | `gitnexus-cursor-integration/` | Static config for Cursor editor (no build). |
+| SWE-bench Eval | `eval/` | Python evaluation harness (optional; needs Docker + LLM API keys). |
+
+### Running services
+
+- **CLI/Core**: `cd gitnexus && npm run dev` (tsx watch mode) or `npm run build && node dist/cli/index.js <command>`
+- **Web UI**: `cd gitnexus-web && npm run dev` (Vite on port 5173)
+- **Backend mode**: `cd <indexed-repo> && node /workspace/gitnexus/dist/cli/index.js serve` (HTTP API on port 3741 by default)
+
+### Testing
+
+**CLI / Core (`gitnexus/`)**
+- **Unit tests**: `cd gitnexus && npm test` (vitest, ~2000 tests)
+- **Integration tests**: `cd gitnexus && npm run test:integration` (vitest, ~1850 tests). Two LadybugDB file-locking tests (`lbug-core-adapter`, `search-core`) may fail in containerized environments due to `/tmp` locking limitations — this is a known environment issue, not a code bug.
+- **TypeScript check**: `cd gitnexus && npx tsc --noEmit`
+
+**Web UI (`gitnexus-web/`)**
+- **Unit tests**: `cd gitnexus-web && npm test` (vitest, ~200 tests)
+- **E2E tests**: `cd gitnexus-web && E2E=1 npx playwright test` (Playwright, 5 tests — requires `gitnexus serve` + `npm run dev` running)
+- **TypeScript check**: `cd gitnexus-web && npx tsc -b --noEmit`
+
+No separate lint command is configured; TypeScript strict checking serves as the primary static analysis.
+
+### Gotchas
+
+- `npm install` in `gitnexus/` triggers `prepare` (builds via `tsc`) and `postinstall` (patches tree-sitter-swift). Native tree-sitter bindings require `python3`, `make`, and `g++` to be present.
+- `tree-sitter-kotlin` and `tree-sitter-swift` are optional dependencies — install warnings for these are expected and non-blocking.
+- The Web UI uses `vite-plugin-wasm` and requires `Cross-Origin-Opener-Policy`/`Cross-Origin-Embedder-Policy` headers for `SharedArrayBuffer` (handled automatically by Vite dev server).
+- There is no ESLint/Prettier configuration in this repo.

ARCHITECTURE.md

@@ -0,0 +1,66 @@
+# Architecture — GitNexus
+
+This repository is a **monorepo** with two main products: the **CLI / MCP package** (`gitnexus/`) and the **browser UI** (`gitnexus-web/`). Supporting folders ship editor integrations and plugins without changing the core graph engine.
+
+## Repository layout
+
+| Path | Role |
+|------|------|
+| `gitnexus/` | Published npm package `gitnexus`: CLI, MCP server (stdio), local HTTP API for bridge mode, ingestion pipeline, LadybugDB graph, embeddings (optional). |
+| `gitnexus-web/` | Vite + React UI: in-browser indexing (WASM), graph visualization, optional connection to `gitnexus serve`. |
+| `.claude/`, `gitnexus-claude-plugin/`, `gitnexus-cursor-integration/` | Packaged **skills** and plugin metadata so agents discover the same workflows as documented in `AGENTS.md`. |
+| `eval/` | Evaluation harnesses and docs for benchmarking tool usage. |
+| `.github/` | CI workflows (quality, unit, integration, E2E) and composite actions. |
+
+## End-to-end flow: index → graph → tools
+
+1. **Ingestion** (`gitnexus analyze`)  
+   - Entry: `gitnexus/src/cli/analyze.ts` → `runPipelineFromRepo` in `gitnexus/src/core/ingestion/pipeline.ts`.  
+   - Walks the git working tree, parses supported languages via **Tree-sitter**, resolves imports/calls/inheritance, detects **communities** and **processes** (execution flows), and builds an in-memory **knowledge graph** (`gitnexus/src/core/graph/`).  
+   - Output is loaded into **LadybugDB** under **`.gitnexus/`** at the repo root (`lbug/`, `meta.json`, etc.). Optional **FTS** indexes and **embeddings** attach to the same store.  
+   - The repo is registered in **`~/.gitnexus/registry.json`** so MCP can find it from any working directory.
+
+2. **Persistence & metadata**  
+   - `gitnexus/src/storage/repo-manager.ts` — paths, registry, cleanup of legacy Kuzu artifacts.  
+   - `gitnexus/src/core/lbug/lbug-adapter.ts` — graph load, queries, embedding restore batches.
+
+3. **Query & agents**  
+   - **MCP (stdio):** `gitnexus/src/cli/mcp.ts` → `startMCPServer` → `LocalBackend` (`gitnexus/src/mcp/local/local-backend.ts`) opens registered repos and serves **tools** from `gitnexus/src/mcp/tools.ts` and **resources** from `gitnexus/src/mcp/resources.ts`.  
+   - **Bridge HTTP:** `gitnexus/src/cli/serve.ts` → Express app in `gitnexus/src/server/api.ts` (CORS-limited) exposes REST + MCP-over-HTTP for the web UI.  
+   - **CLI tools (no MCP):** `gitnexus query`, `context`, `impact`, `cypher` in `gitnexus/src/cli/tool.ts` call the same backend for scripts and CI.
+
+4. **Staleness**  
+   - `gitnexus/src/mcp/staleness.ts` compares indexed `lastCommit` to `HEAD` and surfaces hints when the graph is behind git.
+
+## MCP tools (summary)
+
+| Tool | Purpose |
+|------|---------|
+| `list_repos` | Discover indexed repositories when more than one is registered. |
+| `query` | Natural-language / keyword search over the graph (hybrid BM25 + optional vectors). |
+| `cypher` | Ad hoc **Cypher** against the schema (see resource `gitnexus://repo/{name}/schema`). |
+| `context` | Callers, callees, processes for one symbol (with disambiguation). |
+| `impact` | Blast radius (upstream/downstream) with depth and risk summary. |
+| `detect_changes` | Map git diffs to affected symbols and processes. |
+| `rename` | Graph-assisted rename with `dry_run` preview (`graph` vs `text_search` confidence). |
+
+## Where to change what
+
+| If you are changing… | Start in… |
+|----------------------|-----------|
+| CLI commands / flags | `gitnexus/src/cli/` (`index.ts`, per-command modules). |
+| Parsing or graph construction | `gitnexus/src/core/ingestion/` (pipeline, processors, resolvers, type-extractors). |
+| Graph schema / DB access | `gitnexus/src/core/lbug/` (`schema.ts`, `lbug-adapter.ts`), `gitnexus/src/mcp/core/lbug-adapter.ts` if MCP-specific. |
+| MCP protocol, tools, resources | `gitnexus/src/mcp/server.ts`, `tools.ts`, `resources.ts`. |
+| Search ranking | `gitnexus/src/core/search/` (BM25, hybrid fusion). |
+| Embeddings | `gitnexus/src/core/embeddings/`, phases in `analyze.ts`. |
+| Wiki generation | `gitnexus/src/core/wiki/`. |
+| Web UI behavior | `gitnexus-web/src/` (components, workers, graph client). |
+| CI | `.github/workflows/*.yml`, `.github/actions/setup-gitnexus/`. |
+
+## Related docs
+
+- [RUNBOOK.md](RUNBOOK.md) — operational commands and recovery.  
+- [GUARDRAILS.md](GUARDRAILS.md) — safety boundaries for humans and agents.  
+- [TESTING.md](TESTING.md) — how to run tests.  
+- `AGENTS.md` / `CLAUDE.md` — agent workflows and tool usage expectations for **this** repo when indexed by GitNexus.

CLAUDE.md

@@ -1,101 +1,52 @@
-<!-- gitnexus:start -->
-# GitNexus — Code Intelligence
+<!-- version: 1.2.0 -->
+<!--
+  Metadata: version, last reviewed, scope, model policy, reference docs, changelog.
+  Last updated: 2026-03-22
+-->
 
-This project is indexed by GitNexus as **GitNexus** (1999 symbols, 4681 relationships, 149 execution flows). Use the GitNexus MCP tools to understand code, assess impact, and navigate safely.
+Last reviewed: 2026-03-24
 
-> If any GitNexus tool warns the index is stale, run `npx gitnexus analyze` in terminal first.
+**Project:** GitNexus · **Environment:** dev · **Maintainer:** repository maintainers (see GitHub)
 
-## Always Do
+Follow **AGENTS.md** for the canonical rules; this file adds Claude Code–specific deltas. Cursor-specific notes live only in `AGENTS.md`.
 
-- **MUST run impact analysis before editing any symbol.** Before modifying a function, class, or method, run `gitnexus_impact({target: "symbolName", direction: "upstream"})` and report the blast radius (direct callers, affected processes, risk level) to the user.
-- **MUST run `gitnexus_detect_changes()` before committing** to verify your changes only affect expected symbols and execution flows.
-- **MUST warn the user** if impact analysis returns HIGH or CRITICAL risk before proceeding with edits.
-- When exploring unfamiliar code, use `gitnexus_query({query: "concept"})` to find execution flows instead of grepping. It returns process-grouped results ranked by relevance.
-- When you need full context on a specific symbol — callers, callees, which execution flows it participates in — use `gitnexus_context({name: "symbolName"})`.
+## Scope
 
-## When Debugging
+See the **Scope** table in [AGENTS.md](AGENTS.md) for read/write/execute/off-limits boundaries. Cursor-specific workflow notes also live only in AGENTS.md.
 
-1. `gitnexus_query({query: "<error or symptom>"})` — find execution flows related to the issue
-2. `gitnexus_context({name: "<suspect function>"})` — see all callers, callees, and process participation
-3. `READ gitnexus://repo/GitNexus/process/{processName}` — trace the full execution flow step by step
-4. For regressions: `gitnexus_detect_changes({scope: "compare", base_ref: "main"})` — see what your branch changed
+## Model Configuration
 
-## When Refactoring
+- **Primary:** Pin per **Claude Code** / Anthropic org policy (explicit model id). Do not rely on an unversioned `latest` alias for governed workflows.
+- **Fallback:** As configured in Claude Code (organization default or user override).
+- **Notes:** The GitNexus CLI analyzer does not call an LLM.
 
-- **Renaming**: MUST use `gitnexus_rename({symbol_name: "old", new_name: "new", dry_run: true})` first. Review the preview — graph edits are safe, text_search edits need manual review. Then run with `dry_run: false`.
-- **Extracting/Splitting**: MUST run `gitnexus_context({name: "target"})` to see all incoming/outgoing refs, then `gitnexus_impact({target: "target", direction: "upstream"})` to find all external callers before moving code.
-- After any refactor: run `gitnexus_detect_changes({scope: "all"})` to verify only expected files changed.
+## Execution Sequence (complex tasks)
 
-## Never Do
+Same discipline as [AGENTS.md](AGENTS.md): before large multi-step work, state which **AGENTS.md** / **GUARDRAILS.md** rules apply, current **Scope**, and planned validation commands (`npm test`, `tsc`, etc.). When pausing, summarize progress in the chat or a **local** scratch file (do not add `HANDOFF.md` to the repo), then `/clear` and resume with that summary.
 
-- NEVER edit a function, class, or method without first running `gitnexus_impact` on it.
-- NEVER ignore HIGH or CRITICAL risk warnings from impact analysis.
-- NEVER rename symbols with find-and-replace — use `gitnexus_rename` which understands the call graph.
-- NEVER commit changes without running `gitnexus_detect_changes()` to check affected scope.
+## Claude Code hooks
 
-## Tools Quick Reference
+Prefer **PreToolUse** hooks for hard gates (e.g. tests before `git_commit`). Adapt hook commands to `gitnexus/` npm scripts.
 
-| Tool | When to use | Command |
-|------|-------------|---------|
-| `query` | Find code by concept | `gitnexus_query({query: "auth validation"})` |
-| `context` | 360-degree view of one symbol | `gitnexus_context({name: "validateUser"})` |
-| `impact` | Blast radius before editing | `gitnexus_impact({target: "X", direction: "upstream"})` |
-| `detect_changes` | Pre-commit scope check | `gitnexus_detect_changes({scope: "staged"})` |
-| `rename` | Safe multi-file rename | `gitnexus_rename({symbol_name: "old", new_name: "new", dry_run: true})` |
-| `cypher` | Custom graph queries | `gitnexus_cypher({query: "MATCH ..."})` |
+## Context budget
 
-## Impact Risk Levels
+If always-on instructions grow, load deep conventions via conditional reads (e.g. *“When writing new code, read STANDARDS.md”*) instead of pasting long blocks here. In Cursor, prefer `.cursor/index.mdc` plus optional `.cursor/rules/*.mdc` globs (see [AGENTS.md](AGENTS.md) § Context budget).
 
-| Depth | Meaning | Action |
-|-------|---------|--------|
-| d=1 | WILL BREAK — direct callers/importers | MUST update these |
-| d=2 | LIKELY AFFECTED — indirect deps | Should test |
-| d=3 | MAY NEED TESTING — transitive | Test if critical path |
+## Reference Documentation
 
-## Resources
+- **This repository:** [AGENTS.md](AGENTS.md) (Cursor + monorepo notes), [ARCHITECTURE.md](ARCHITECTURE.md), [CONTRIBUTING.md](CONTRIBUTING.md), [GUARDRAILS.md](GUARDRAILS.md).
+- **GitNexus:** `.claude/skills/gitnexus/`; MCP and indexed-repo rules live only in [AGENTS.md](AGENTS.md) (`gitnexus:start` … `gitnexus:end`). See **GitNexus rules** below.
 
-| Resource | Use for |
-|----------|---------|
-| `gitnexus://repo/GitNexus/context` | Codebase overview, check index freshness |
-| `gitnexus://repo/GitNexus/clusters` | All functional areas |
-| `gitnexus://repo/GitNexus/processes` | All execution flows |
-| `gitnexus://repo/GitNexus/process/{name}` | Step-by-step execution trace |
+## Changelog
 
-## Self-Check Before Finishing
+| Date | Version | Change |
+|------|---------|--------|
+| 2026-03-24 | 1.2.0 | Removed duplicated gitnexus:start block and scope table; replaced with pointers to AGENTS.md. |
+| 2026-03-23 | 1.1.0 | Updated agent instructions to match AGENTS.md. |
+| 2026-03-22 | 1.0.0 | Added structured header and changelog. |
 
-Before completing any code modification task, verify:
-1. `gitnexus_impact` was run for all modified symbols
-2. No HIGH/CRITICAL risk warnings were ignored
-3. `gitnexus_detect_changes()` confirms changes match expected scope
-4. All d=1 (WILL BREAK) dependents were updated
+---
 
-## Keeping the Index Fresh
+## GitNexus rules
 
-After committing code changes, the GitNexus index becomes stale. Re-run analyze to update it:
-
-```bash
-npx gitnexus analyze
-```
-
-If the index previously included embeddings, preserve them by adding `--embeddings`:
-
-```bash
-npx gitnexus analyze --embeddings
-```
-
-To check whether embeddings exist, inspect `.gitnexus/meta.json` — the `stats.embeddings` field shows the count (0 means no embeddings). **Running analyze without `--embeddings` will delete any previously generated embeddings.**
-
-> Claude Code users: A PostToolUse hook handles this automatically after `git commit` and `git merge`.
-
-## CLI
-
-| Task | Read this skill file |
-|------|---------------------|
-| Understand architecture / "How does X work?" | `.claude/skills/gitnexus/gitnexus-exploring/SKILL.md` |
-| Blast radius / "What breaks if I change X?" | `.claude/skills/gitnexus/gitnexus-impact-analysis/SKILL.md` |
-| Trace bugs / "Why is X failing?" | `.claude/skills/gitnexus/gitnexus-debugging/SKILL.md` |
-| Rename / extract / split / refactor | `.claude/skills/gitnexus/gitnexus-refactoring/SKILL.md` |
-| Tools, resources, schema reference | `.claude/skills/gitnexus/gitnexus-guide/SKILL.md` |
-| Index, status, clean, wiki CLI commands | `.claude/skills/gitnexus/gitnexus-cli/SKILL.md` |
-
-<!-- gitnexus:end -->
+GitNexus MCP rules are in the `<!-- gitnexus:start -->` … `<!-- gitnexus:end -->` block in **[AGENTS.md](AGENTS.md)** — load that section when working with MCP tools or the graph index.

CONTRIBUTING.md

@@ -0,0 +1,50 @@
+# Contributing to GitNexus
+
+How to propose changes, run checks locally, and open pull requests.
+
+## License
+
+This project uses the [PolyForm Noncommercial License 1.0.0](https://polyformproject.org/licenses/noncommercial/1.0.0/). By contributing, you agree your contributions are licensed under the same terms unless stated otherwise.
+
+## Where to discuss
+
+- **Issues & feature ideas:** use [GitHub Issues](https://github.com/abhigyanpatwari/GitNexus/issues) for the upstream repo, or your fork’s tracker if you work from a fork.
+- **Community:** see the Discord link in the root [README.md](README.md).
+
+## Development setup
+
+1. Clone the repository.
+2. **CLI / MCP package:** `cd gitnexus && npm install && npm run build`
+3. **Web UI (if needed):** `cd gitnexus-web && npm install`
+4. Run tests as described in [TESTING.md](TESTING.md).
+
+## Branch and pull requests
+
+- Use short-lived branches off the default branch of the repo you are targeting.
+- Prefer **conventional commits** (short prefix + description), for example:
+
+  ```text
+  feat: add graph export option
+  fix: correct MCP tool schema for query
+  test: cover cluster merge edge case
+  docs: clarify analyze flags
+  ```
+
+- **PR title:** `[area] Short description` (e.g. `[cli] Fix index refresh race`).
+- **PR description:** what changed, why, how to verify (commands), and any risk or rollback notes.
+
+## Before you open a PR
+
+- [ ] Tests pass for the packages you touched (`gitnexus` and/or `gitnexus-web`).
+- [ ] Typecheck passes: `npx tsc --noEmit` in `gitnexus/` and `npx tsc -b --noEmit` in `gitnexus-web/`.
+- [ ] No secrets, tokens, or machine-specific paths committed.
+- [ ] Documentation updated if behavior or public CLI/MCP contract changes.
+- [ ] Pre-commit hook runs clean (`.husky/pre-commit` — typecheck + unit tests for staged packages).
+
+## Code review
+
+Maintainers may request changes for correctness, tests, performance, or consistency with existing patterns. Keeping diffs focused makes review faster.
+
+## AI-assisted contributions
+
+If you use coding agents, follow project context files (e.g. `AGENTS.md`, `CLAUDE.md`) and avoid drive-by refactors unrelated to the issue. Prefer incremental, test-backed changes.

GUARDRAILS.md

@@ -0,0 +1,88 @@
+# Guardrails — GitNexus (repo + agents)
+
+Rules for **human contributors** and **AI agents** working on this codebase or publishing artifacts. These complement `AGENTS.md` / `CLAUDE.md` (which focus on GitNexus-in-GitNexus workflows).
+
+## Scope (typical agent session)
+
+When automating changes in this repository, treat scope as **least privilege**:
+
+- **Read:** Source, tests, docs, public config as needed for the task.  
+- **Write:** Only files required for the requested fix or feature; avoid unrelated formatting or refactors.  
+- **Execute:** Tests, typecheck, and documented CLI commands; do not run destructive commands on user data outside the repo without explicit approval.  
+- **Off-limits:** Other people’s machines, production deployments you don’t own, and credentials you didn’t receive permission to use.
+
+Adjust explicitly if the maintainer defines a different scope for a task.
+
+---
+
+## Non-negotiables
+
+1. **Never commit secrets** — API keys, tokens, `.env` with real values, private URLs, or session cookies. Use `.env.example` with placeholders only.  
+2. **Never rename symbols with blind find-and-replace** when working in a GitNexus-indexed project — use the **`rename` MCP tool** with **`dry_run: true` first**, then review `graph` vs `text_search` edits. (There is no separate `gitnexus rename` CLI; renaming goes through MCP or editor integration.)  
+3. **Run impact analysis before editing shared symbols** — use **`impact`** (upstream) for functions/classes/methods others call; do not ignore **HIGH** / **CRITICAL** risk without maintainer sign-off.  
+4. **Prefer `detect_changes` before commit** — confirm diffs map to expected symbols/processes when the graph is available.  
+5. **Preserve embeddings** — if `.gitnexus/meta.json` shows embeddings, run `npx gitnexus analyze --embeddings` when refreshing the index; plain `analyze` can drop them.
+
+---
+
+## Signs (recurring failure patterns)
+
+Use this format: **Trigger → Instruction → Reason**.  
+Append new Signs here when the same mistake repeats (e.g. CI broken twice the same way).
+
+### Sign: Stale graph after edits
+
+- **Trigger:** MCP or resources warn the index is behind `HEAD`, or code search doesn’t match latest commit.  
+- **Instruction:** Run `npx gitnexus analyze` from the repo root (plus `--embeddings` if the project used them).  
+- **Reason:** Tools query LadybugDB built at last analyze; git changes are invisible until re-indexed.
+
+### Sign: Embeddings vanished after analyze
+
+- **Trigger:** Semantic search quality drops; `stats.embeddings` in `.gitnexus/meta.json` is 0 after a refresh.  
+- **Instruction:** Re-run `npx gitnexus analyze --embeddings` and confirm `meta.json` reflects stored embeddings.  
+- **Reason:** Embedding generation is opt-in; analyze without the flag does not preserve prior vectors.
+
+### Sign: MCP lists no repos
+
+- **Trigger:** MCP stderr says no indexed repos.  
+- **Instruction:** Run `npx gitnexus analyze` in the target repository; verify `npx gitnexus list` shows it.  
+- **Reason:** The MCP server discovers repos via `~/.gitnexus/registry.json`, populated by analyze.
+
+### Sign: Wrong repo in multi-repo setups
+
+- **Trigger:** Query/impact results clearly belong to another project.  
+- **Instruction:** Call `list_repos`, then pass **`repo`** on subsequent tools (or use per-workspace MCP config).  
+- **Reason:** Default target may be ambiguous when multiple repos are registered.
+
+### Sign: LadybugDB lock / “database busy”
+
+- **Trigger:** Errors opening `.gitnexus/lbug` while MCP and analyze both run.  
+- **Instruction:** Stop overlapping processes; one writer at a time. Retry analyze or restart MCP.  
+- **Reason:** Embedded DB expects single-process ownership of the store.
+
+---
+
+## Publishing & supply chain
+
+- **npm:** Do not publish from unreviewed automation; follow maintainer release process. Bump version intentionally; tag releases to match `package.json`.  
+- **Dependencies:** Prefer minimal, auditable changes to `package.json`; run tests and CI after lockfile updates.  
+- **License:** This project ships under **PolyForm Noncommercial 1.0.0** — do not relicense or imply a different license in docs or metadata without maintainer approval.
+
+---
+
+## Escalation
+
+Stop and ask a **human maintainer** when:
+
+- Impact analysis shows **HIGH** / **CRITICAL** risk and the task still requires the change.  
+- You need to alter **CI**, **release**, or **security-sensitive** config.  
+- Requirements conflict (e.g. “speed up analyze” vs “must keep all embeddings on huge repo”).  
+- You are unsure whether data loss is acceptable (`clean`, forced migrations, schema changes).
+
+---
+
+## Related docs
+
+- [ARCHITECTURE.md](ARCHITECTURE.md) — components and data flow.  
+- [RUNBOOK.md](RUNBOOK.md) — commands for recovery.  
+- [CONTRIBUTING.md](CONTRIBUTING.md) — PR and commit expectations.

README.md

@@ -19,6 +19,8 @@
     <img src="https://img.shields.io/badge/License-PolyForm%20Noncommercial-blue.svg" alt="License: PolyForm Noncommercial"/>
   </a>
 
+  <p><strong>Enterprise (SaaS & Self-hosted)</strong> - <a href="https://akonlabs.com">akonlabs.com</a></p>
+
 </div>
 
 **Building nervous system for agent context.**
@@ -34,7 +36,7 @@ https://github.com/user-attachments/assets/172685ba-8e54-4ea7-9ad1-e31a3398da72
 
 > *Like DeepWiki, but deeper.* DeepWiki helps you *understand* code. GitNexus lets you *analyze* it — because a knowledge graph tracks every relationship, not just descriptions.
 
-**TL;DR:** The **Web UI** is a quick way to chat with any repo. The **CLI + MCP** is how you make your AI agent actually reliable — it gives Cursor, Claude Code, and friends a deep architectural view of your codebase so they stop missing dependencies, breaking call chains, and shipping blind edits. Even smaller models get full architectural clarity, making it compete with goliath models.
+**TL;DR:** The **Web UI** is a quick way to chat with any repo. The **CLI + MCP** is how you make your AI agent actually reliable — it gives Cursor, Claude Code, Codex, and friends a deep architectural view of your codebase so they stop missing dependencies, breaking call chains, and shipping blind edits. Even smaller models get full architectural clarity, making it compete with goliath models.
 
 ---
 
@@ -48,7 +50,7 @@ https://github.com/user-attachments/assets/172685ba-8e54-4ea7-9ad1-e31a3398da72
 |                   | **CLI + MCP**                                            | **Web UI**                                             |
 | ----------------- | -------------------------------------------------------------- | ------------------------------------------------------------ |
 | **What**    | Index repos locally, connect AI agents via MCP                 | Visual graph explorer + AI chat in browser                   |
-| **For**     | Daily development with Cursor, Claude Code, Windsurf, OpenCode | Quick exploration, demos, one-off analysis                   |
+| **For**     | Daily development with Cursor, Claude Code, Codex, Windsurf, OpenCode | Quick exploration, demos, one-off analysis                   |
 | **Scale**   | Full repos, any size                                           | Limited by browser memory (~5k files), or unlimited via backend mode |
 | **Install** | `npm install -g gitnexus`                                    | No install —[gitnexus.vercel.app](https://gitnexus.vercel.app) |
 | **Storage** | LadybugDB native (fast, persistent)                               | LadybugDB WASM (in-memory, per session)                         |
@@ -59,6 +61,36 @@ https://github.com/user-attachments/assets/172685ba-8e54-4ea7-9ad1-e31a3398da72
 
 ---
 
+## Enterprise
+
+GitNexus is available as an **enterprise offering** - either as a fully managed **SaaS** or a **self-hosted** deployment. Also available for **commercial use** of the OSS version with proper licensing.
+
+Enterprise includes:
+- **PR Review** - automated blast radius analysis on pull requests
+- **Auto-updating Code Wiki** - always up-to-date documentation (Code Wiki is also available in OSS)
+- **Auto-reindexing** - knowledge graph stays fresh automatically
+- **Multi-repo support** - unified graph across repositories
+- **OCaml support** - additional language coverage
+- **Priority feature/language support** - request new languages or features
+
+**Upcoming:**
+- Auto regression forensics
+- End-to-end test generation
+
+👉 Learn more at [akonlabs.com](https://akonlabs.com)
+
+💬 For commercial licensing or enterprise inquiries, ping us on [Discord](https://discord.gg/AAsRVT6fGb) or drop an email at founders@akonlabs.com
+
+---
+
+## Development
+
+- [ARCHITECTURE.md](ARCHITECTURE.md) — packages, index → graph → MCP flow, where to change code
+- [RUNBOOK.md](RUNBOOK.md) — analyze, embeddings, stale index, MCP recovery, CI snippets
+- [GUARDRAILS.md](GUARDRAILS.md) — safety rules and operational “Signs” for contributors and agents
+- [CONTRIBUTING.md](CONTRIBUTING.md) — license, setup, commits, and pull requests
+- [TESTING.md](TESTING.md) — test commands for `gitnexus` and `gitnexus-web`
+
 ## CLI + MCP (recommended)
 
 The CLI indexes your repository and runs an MCP server that gives AI agents deep codebase awareness.
@@ -84,23 +116,40 @@ To configure MCP for your editor, run `npx gitnexus setup` once — or set it up
 | --------------------- | --- | ------ | -------------------- | -------------- |
 | **Claude Code** | Yes | Yes    | Yes (PreToolUse + PostToolUse) | **Full** |
 | **Cursor**      | Yes | Yes    | —                   | MCP + Skills   |
+| **Codex**       | Yes | Yes    | —                   | MCP + Skills   |
 | **Windsurf**    | Yes | —     | —                   | MCP            |
 | **OpenCode**    | Yes | Yes    | —                   | MCP + Skills   |
+| **Codex**       | Yes | —     | —                   | MCP            |
 
 > **Claude Code** gets the deepest integration: MCP tools + agent skills + PreToolUse hooks that enrich searches with graph context + PostToolUse hooks that auto-reindex after commits.
 
-### Community Integrations
+## Community Integrations
 
-| Agent | Install | Source |
-|-------|---------|--------|
-| [pi](https://pi.dev) | `pi install npm:pi-gitnexus` | [pi-gitnexus](https://github.com/tintinweb/pi-gitnexus) |
+Built by the community — not officially maintained, but worth checking out.
+
+| Project | Author | Description |
+|---------|--------|-------------|
+| [pi-gitnexus](https://github.com/tintinweb/pi-gitnexus) | [@tintinweb](https://github.com/tintinweb) | GitNexus plugin for [pi](https://pi.dev) — `pi install npm:pi-gitnexus` |
+| [gitnexus-stable-ops](https://github.com/ShunsukeHayashi/gitnexus-stable-ops) | [@ShunsukeHayashi](https://github.com/ShunsukeHayashi) | Stable ops & deployment workflows (Miyabi ecosystem) |
+
+> Have a project built on GitNexus? Open a PR to add it here!
 
 If you prefer manual configuration:
 
 **Claude Code** (full support — MCP + skills + hooks):
 
 ```bash
+# macOS / Linux
 claude mcp add gitnexus -- npx -y gitnexus@latest mcp
+
+# Windows
+claude mcp add gitnexus -- cmd /c npx -y gitnexus@latest mcp
+```
+
+**Codex** (full support — MCP + skills):
+
+```bash
+codex mcp add gitnexus -- npx -y gitnexus@latest mcp
 ```
 
 **Cursor** (`~/.cursor/mcp.json` — global, works for all projects):
@@ -122,23 +171,32 @@ claude mcp add gitnexus -- npx -y gitnexus@latest mcp
 {
   "mcp": {
     "gitnexus": {
-      "command": "npx",
-      "args": ["-y", "gitnexus@latest", "mcp"]
+      "type": "local",
+      "command": ["gitnexus", "mcp"]
     }
   }
 }
 ```
 
+**Codex** (`~/.codex/config.toml` for system scope, or `.codex/config.toml` for project scope):
+
+```toml
+[mcp_servers.gitnexus]
+command = "npx"
+args = ["-y", "gitnexus@latest", "mcp"]
+```
+
 ### CLI Commands
 
 ```bash
-gitnexus setup                    # Configure MCP for your editors (one-time)
-gitnexus analyze [path]           # Index a repository (or update stale index)
-gitnexus analyze --force          # Force full re-index
-gitnexus analyze --skills         # Generate repo-specific skill files from detected communities
+gitnexus setup                   # Configure MCP for your editors (one-time)
+gitnexus analyze [path]          # Index a repository (or update stale index)
+gitnexus analyze --force         # Force full re-index
+gitnexus analyze --skills        # Generate repo-specific skill files from detected communities
 gitnexus analyze --skip-embeddings  # Skip embedding generation (faster)
-gitnexus analyze --embeddings     # Enable embedding generation (slower, better search)
-gitnexus analyze --verbose        # Log skipped files when parsers are unavailable
+gitnexus analyze --skip-agents-md  # Preserve custom AGENTS.md/CLAUDE.md gitnexus section edits
+gitnexus analyze --embeddings    # Enable embedding generation (slower, better search)
+gitnexus analyze --verbose       # Log skipped files when parsers are unavailable
 gitnexus mcp                     # Start MCP server (stdio) — serves all indexed repos
 gitnexus serve                   # Start local HTTP server (multi-repo) for web UI connection
 gitnexus list                    # List all indexed repositories
@@ -258,8 +316,8 @@ Or run locally:
 
 ```bash
 git clone https://github.com/abhigyanpatwari/gitnexus.git
-cd gitnexus/gitnexus-web
-npm install
+cd gitnexus/gitnexus-shared && npm install && npm run build
+cd ../gitnexus-web && npm install
 npm run dev
 ```
 
@@ -271,7 +329,7 @@ The web UI uses the same indexing pipeline as the CLI but runs entirely in WebAs
 
 ## The Problem GitNexus Solves
 
-Tools like **Cursor**, **Claude Code**, **Cline**, **Roo Code**, and **Windsurf** are powerful — but they don't truly know your codebase structure.
+Tools like **Cursor**, **Claude Code**, **Codex**, **Cline**, **Roo Code**, and **Windsurf** are powerful — but they don't truly know your codebase structure.
 
 **What happens:**
 
@@ -342,6 +400,7 @@ GitNexus builds a complete knowledge graph of your codebase through a multi-phas
 | Swift | — | — | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
 | C | — | — | ✓ | — | ✓ | ✓ | — | ✓ | ✓ |
 | C++ | — | — | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
+| Dart | ✓ | — | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
 
 **Imports** — cross-file import resolution · **Named Bindings** — `import { X as Y }` / re-export tracking · **Exports** — public/exported symbol detection · **Heritage** — class inheritance, interfaces, mixins · **Type Annotations** — explicit type extraction for receiver resolution · **Constructor Inference** — infer receiver type from constructor calls (`self`/`this` resolution included for all languages) · **Config** — language toolchain config parsing (tsconfig, go.mod, etc.) · **Frameworks** — AST-based framework pattern detection · **Entry Points** — entry point scoring heuristics
 
@@ -506,7 +565,7 @@ The wiki generator reads the indexed graph structure, groups files into modules
 - [X] Constructor-Inferred Type Resolution, `self`/`this` Receiver Mapping
 - [X] Wiki Generation, Multi-File Rename, Git-Diff Impact Analysis
 - [X] Process-Grouped Search, 360-Degree Context, Claude Code Hooks
-- [X] Multi-Repo MCP, Zero-Config Setup, 13 Language Support
+- [X] Multi-Repo MCP, Zero-Config Setup, 14 Language Support
 - [X] Community Detection, Process Detection, Confidence Scoring
 - [X] Hybrid Search, Vector Index
 

RUNBOOK.md

@@ -0,0 +1,163 @@
+# Runbook — GitNexus
+
+Short, copy-paste operations for **local development**, **MCP**, and **CI**. Commands assume a Unix shell; on Windows use Git Bash or equivalent paths.
+
+## Prerequisites
+
+- **Node.js** ≥ 20 (`gitnexus-web/package.json` `engines`).  
+- **Git** (analyze requires a git repository).  
+- From repo root, install and build the CLI package:
+
+```bash
+cd gitnexus
+npm install
+npm run build
+```
+
+Use `npx gitnexus …` from any path after global/published install, or `node dist/cli/index.js …` when developing from `gitnexus/` with a local build.
+
+---
+
+## Index out of date / “stale” tools
+
+**Symptom:** MCP or resources warn the index is behind `HEAD`, or results don’t reflect recent commits.
+
+**Fix (from the target repo root):**
+
+```bash
+npx gitnexus analyze
+```
+
+**Force full rebuild** (same commit but suspect corruption or changed ignore rules):
+
+```bash
+npx gitnexus analyze --force
+```
+
+**Check status:**
+
+```bash
+npx gitnexus status
+```
+
+**List what MCP knows about:**
+
+```bash
+npx gitnexus list
+```
+
+---
+
+## Embeddings
+
+**First time with vectors** (slower, more disk/RAM):
+
+```bash
+npx gitnexus analyze --embeddings
+```
+
+**Important:** If you already had embeddings, **always** pass `--embeddings` on later analyzes, or they can be dropped. See `stats.embeddings` in `.gitnexus/meta.json` (0 means none).
+
+**Large repos:** Analyze may skip or limit embedding work when node counts are very high; watch CLI output.
+
+---
+
+## MCP: no repos / empty tools
+
+**Symptom:** `GitNexus: No indexed repos yet` on stderr when starting MCP.
+
+**Fix:** In each project you want indexed:
+
+```bash
+cd /path/to/repo
+npx gitnexus analyze
+```
+
+Restart the editor MCP session if needed. The server **refreshes the registry lazily**; new analyzes are picked up without necessarily reinstalling MCP.
+
+**Symptom:** Wrong repo when multiple are indexed — pass `repo` on tools or use `list_repos` first.
+
+---
+
+## Clean slate (corrupt or huge `.gitnexus`)
+
+**Current repo only** (prompts for confirmation):
+
+```bash
+npx gitnexus clean
+```
+
+**Skip confirmation:**
+
+```bash
+npx gitnexus clean --force
+```
+
+**All registered repos:**
+
+```bash
+npx gitnexus clean --all --force
+```
+
+Then re-run `npx gitnexus analyze` (and `--embeddings` if you need vectors).
+
+---
+
+## Local bridge for the web UI
+
+```bash
+cd gitnexus
+npx gitnexus serve
+# default http://127.0.0.1:4747 — see serve --help for port/host
+```
+
+Use when the browser UI should talk to **local** indexed repos instead of WASM-only mode.
+
+---
+
+## CLI equivalents of MCP tools
+
+Useful for debugging without an editor:
+
+```bash
+cd gitnexus
+npx gitnexus query "authentication flow" --repo MyRepo
+npx gitnexus context SomeSymbol --repo MyRepo
+npx gitnexus impact SomeSymbol --direction upstream --repo MyRepo
+npx gitnexus cypher "MATCH (n) RETURN count(n) LIMIT 1" --repo MyRepo
+```
+
+---
+
+## CI failures (contributors)
+
+Orchestrator: `.github/workflows/ci.yml`.
+
+| Job | Typical local repro |
+|-----|---------------------|
+| **quality** | `cd gitnexus && npx tsc --noEmit` |
+| **unit-tests** | `cd gitnexus && npx vitest run test/unit` |
+| **integration** | `cd gitnexus && npx vitest run test/integration` (see workflow matrix for groups) |
+| **e2e** | Triggered when `gitnexus-web/` changes; `cd gitnexus-web && E2E=1 npx playwright test` (requires `gitnexus serve` + `npm run dev`) |
+
+**Note:** Pushes that touch only certain markdown paths may be skipped by `paths-ignore` in CI — see workflow file for exact patterns.
+
+---
+
+## Memory / analyze crashes
+
+Analyze re-execs Node with a **large old-space heap** when needed (`analyze.ts`). If you still OOM on huge repos, close other processes, avoid `--embeddings` for a first pass, or analyze a smaller path if supported by your workflow.
+
+---
+
+## LadybugDB / lock errors
+
+Only one process should open a repo’s `.gitnexus/lbug` store at a time. If MCP and a second `analyze` run conflict, stop one process, then retry `analyze` or restart MCP.
+
+---
+
+## Where to dig deeper
+
+- Architecture overview: [ARCHITECTURE.md](ARCHITECTURE.md)  
+- Agent safety rules: [GUARDRAILS.md](GUARDRAILS.md)  
+- Tests: [TESTING.md](TESTING.md)

TESTING.md

@@ -0,0 +1,95 @@
+# Testing — GitNexus
+
+How we structure tests and which commands to run locally and in CI.
+
+## Packages
+
+| Package        | Path           | Runner   | Notes                          |
+| -------------- | -------------- | -------- | ------------------------------ |
+| CLI + MCP core | `gitnexus/`    | Vitest   | Primary test surface in CI     |
+| Web UI         | `gitnexus-web/`| Vitest   | Unit/component tests           |
+| Web UI E2E     | `gitnexus-web/`| Playwright | Run when changing UI flows   |
+
+## Commands (local)
+
+From repository root, unless noted:
+
+**`gitnexus` (CLI / library)**
+
+```bash
+cd gitnexus
+npm install
+npm run build
+npm test                    # unit: vitest run test/unit
+npm run test:integration    # integration suite
+npm run test:all
+npm run test:coverage
+npx tsc --noEmit            # typecheck (matches CI)
+```
+
+**`gitnexus-web`**
+
+```bash
+cd gitnexus-web
+npm install
+npm test                    # unit tests (vitest)
+npx tsc -b --noEmit         # typecheck (matches CI)
+npm run test:coverage
+npm run test:e2e            # Playwright (requires gitnexus serve + npm run dev)
+```
+
+## Pre-commit hook
+
+A husky pre-commit hook (`.husky/pre-commit`) runs automatically on every `git commit`:
+
+- **`gitnexus-web/` files staged** → `tsc -b --noEmit` + `vitest run`
+- **`gitnexus/` files staged** → `tsc --noEmit` + `vitest run --project default`
+
+Skip with `git commit --no-verify` (use sparingly).
+
+## Test categories
+
+- **Unit** — Pure logic, parsers, graph/query helpers; fast; no network.
+- **Integration** — Real combinations (filesystem, MCP wiring, larger pipelines) as already organized under `gitnexus/test/integration`.
+- **Eval-style / golden sets** — For agent- or classification-style behavior, keep labeled inputs and expected outputs (JSON or table-driven tests) and run them in CI when relevant.
+- **E2E (web)** — Critical user paths only; prefer `data-testid` attributes for stable selectors. Tests run against real backend (`gitnexus serve`) and Vite dev server.
+
+## Performance metrics (targets)
+
+Set targets to match team expectations, then tune to this repo’s CI reality:
+
+| Metric              | Target (initial) | Notes                                      |
+| ------------------- | ---------------- | ------------------------------------------ |
+| Unit coverage       | Align with CI    | CI runs Vitest with coverage in `gitnexus` |
+| Unit wall time      | Fast PR feedback | Use `vitest run test/unit` for tight loop  |
+| Integration duration| < few minutes | Guard heavy tests with env flags if needed |
+
+## Regression testing
+
+Re-run the full relevant suite when:
+
+- Prompt or agent-behavior documentation changes (if tests encode behavior)
+- Model or embedding-related code paths change
+- Graph schema, query contracts, or MCP tool shapes change
+- Dependencies with parsing or runtime impact upgrade
+
+## CI integration
+
+GitHub Actions (`.github/workflows/ci.yml`) orchestrate:
+
+- **`ci-quality.yml`** — `tsc --noEmit` for `gitnexus/` + `tsc -b --noEmit` for `gitnexus-web/`
+- **`ci-tests.yml`** — `vitest run` with coverage (ubuntu) + cross-platform (macOS, Windows)
+- **`ci-e2e.yml`** — Playwright E2E tests, gated on `gitnexus-web/**` changes
+
+Local checks before pushing:
+
+```bash
+cd gitnexus && npx tsc --noEmit && npm test
+cd ../gitnexus-web && npx tsc -b --noEmit && npm test
+```
+
+Or rely on the pre-commit hook which runs these automatically for staged files.
+
+## User acceptance / beta (optional)
+
+For staged releases or UI betas: deploy to a staging environment, collect structured feedback, watch errors and latency, then iterate before a wider release.

compound-engineering.local.md

@@ -0,0 +1,57 @@
+---
+review_agents: [kieran-typescript-reviewer, pattern-recognition-specialist, architecture-strategist, data-integrity-guardian, security-sentinel, performance-oracle, code-simplicity-reviewer]
+plan_review_agents: [kieran-typescript-reviewer, architecture-strategist, code-simplicity-reviewer]
+voltagent_agents: [voltagent-lang:typescript-pro, voltagent-qa-sec:security-auditor, voltagent-data-ai:database-optimizer]
+---
+
+# Review Context
+
+## Project Overview
+GitNexus is a code intelligence tool that builds a knowledge graph from source code using tree-sitter AST parsing across 12 languages and KuzuDB for graph storage. Two packages: `gitnexus/` (CLI/MCP, TypeScript) and `gitnexus-web/` (browser).
+
+## Cross-Language Pattern Consistency (pattern-recognition-specialist)
+- 12 language-specific type extractors in `gitnexus/src/core/ingestion/type-extractors/` must follow identical patterns for: async unwrapping, constructor binding, namespace handling, nullable type stripping, for-loop element typing.
+- Past bugs: C#/Rust missing `await_expression` unwrapping that TypeScript handled correctly; PHP backslash namespace splitting inconsistent with other languages' `::` / `.` splitting.
+- When reviewing type extractor changes, verify the same pattern exists in ALL applicable language files — asymmetry is the #1 source of bugs.
+
+## Data Integrity (data-integrity-guardian)
+- KuzuDB graph operations: schema in `gitnexus/src/core/kuzu/schema.ts`, adapter in `kuzu-adapter.ts`.
+- The ingestion pipeline writes symbols and relationships to the graph — changes to node/relation schemas or the ingestion pipeline can corrupt the index.
+- Known issue: KuzuDB `close()` hangs on Linux due to C++ destructor — use `detachKuzu()` pattern.
+- `lbug-adapter.ts` fallback path needs quote/newline escaping for Cypher injection prevention.
+
+## Security (security-sentinel)
+- Cypher query construction in `lbug-adapter.ts` and `kuzu-adapter.ts` — watch for injection via unescaped user-provided symbol names.
+- CLI accepts `--repo` parameter and file paths — validate against path traversal.
+- MCP server exposes tools to external AI agents — all tool inputs are untrusted.
+
+## Performance (performance-oracle)
+- Tree-sitter buffer size is adaptive (512KB–32MB) via `getTreeSitterBufferSize()` in `constants.ts`.
+- The ingestion pipeline processes entire repositories — O(n) per file with potential O(n²) in cross-file resolution.
+- KuzuDB batch inserts vs individual inserts matter for large repos.
+
+## Architecture (architecture-strategist)
+- Ingestion pipeline phases: structure → parsing → imports → calls → heritage → processes → type resolution.
+- Shared modules: `export-detection.ts`, `constants.ts`, `utils.ts` — changes here have wide blast radius.
+- `gitnexus-web` package drifts behind CLI — flag if a change should be mirrored.
+
+## Voltagent Supplementary Agents
+
+Invoke these via the Agent tool alongside `/ce:review` for deeper specialist analysis. These cover gaps that compound-engineering agents don't:
+
+### voltagent-lang:typescript-pro
+**When:** Changes touch type-resolution logic, generics, conditional types, or complex type-level programming in `type-env.ts`, `type-extractors/*.ts`, or `types.ts`.
+**Why:** The type resolution system uses advanced TypeScript patterns (discriminated unions, mapped types, recursive generics) that benefit from deep TS type-system review beyond what kieran-typescript-reviewer covers.
+
+### voltagent-qa-sec:security-auditor
+**When:** Changes touch MCP tool handlers, Cypher query construction, CLI argument parsing, or any code that processes external input.
+**Why:** GitNexus is an MCP server — all tool inputs come from untrusted AI agents. Systematic OWASP-level audit catches injection vectors that spot-checking misses. Past finding: `lbug-adapter.ts` fallback path had unescaped newlines in Cypher queries.
+
+### voltagent-data-ai:database-optimizer
+**When:** Changes touch `kuzu-adapter.ts`, `schema.ts`, `lbug-adapter.ts`, or any Cypher query construction/execution.
+**Why:** No CE agent specializes in graph database optimization. KuzuDB batch insert patterns, index usage, and query planning directly affect analysis speed on large repos.
+
+## Review Tooling
+- Use `gitnexus_impact()` before approving changes to any symbol — check d=1 (WILL BREAK) callers.
+- Use `gitnexus_detect_changes({scope: "compare", base_ref: "main"})` to map PR diffs to affected execution flows.
+- Use claude-mem to surface past architectural decisions relevant to the code under review.

docs/code-indexing/cobol/README.md

@@ -0,0 +1,100 @@
+# COBOL Code Indexing
+
+GitNexus indexes COBOL codebases using a **regex-only extraction** strategy, bypassing tree-sitter entirely. This document explains why, how the pipeline works, and links to detailed sub-documents.
+
+## Why Regex-Only?
+
+The tree-sitter-cobol grammar (v0.0.1) has three critical limitations that make it unusable for production indexing:
+
+| Issue | Impact | Severity |
+|-------|--------|----------|
+| External scanner hangs on ~5% of files | No timeout mechanism exists for the C scanner; the process blocks indefinitely | **Blocking** |
+| Only ~15% of paragraph headers detected | Most procedure-division paragraphs are invisible to the grammar | High |
+| Patch markers in cols 1-6 cause parse errors | Enterprise COBOL uses non-standard sequence area content (e.g., `mzADD`, `estero`, `#FIX`) | High |
+
+Because the external scanner hang cannot be interrupted (there is no `setTimeoutMicros` equivalent for tree-sitter), using tree-sitter-cobol would hang the indexing pipeline on a non-trivial fraction of real-world files.
+
+The regex-only approach provides:
+
+- **Speed**: ~1ms per file average extraction time
+- **Reliability**: zero hangs, zero crashes across 13,000+ files
+- **Coverage**: captures all critical symbols -- program name, paragraphs, sections, CALL, PERFORM, COPY, data items (01-77, 88-level), file declarations, FD entries, EXEC SQL/CICS blocks, ENTRY points, and MOVE statements
+
+## Architecture
+
+```mermaid
+flowchart TD
+    A[Repository Scan] --> B{File Detection}
+    B -->|Extension match| C[COBOL file]
+    B -->|GITNEXUS_COBOL_DIRS match| C
+    B -->|No match| Z[Skip]
+
+    C --> D{Copybook?}
+    D -->|Yes| E[Add to Copybook Map]
+    D -->|No| F[Source Program]
+
+    E --> G[COPY Expansion Engine]
+    F --> G
+
+    G -->|Inline copybook content| H[Expanded Source]
+    H --> I[Patch Marker Cleanup]
+    I --> J[Regex State Machine]
+
+    J --> K[Extracted Symbols]
+    K --> L[Graph Model Builder]
+    L --> M[Knowledge Graph]
+
+    subgraph "Per-Chunk Processing"
+        G
+        H
+        I
+        J
+        K
+        L
+    end
+
+    subgraph "Post-Processing"
+        M --> N[Community Detection]
+        M --> O[Process Detection]
+        M --> P[Contract Detection]
+    end
+
+    style J fill:#e8f5e9,stroke:#2e7d32
+    style G fill:#e3f2fd,stroke:#1565c0
+```
+
+## COBOL vs Tree-Sitter Languages
+
+| Feature | COBOL (Regex) | Tree-Sitter Languages |
+|---------|--------------|----------------------|
+| Parser | Single-pass regex state machine | tree-sitter grammar + queries |
+| Speed | ~1ms/file | ~5ms/file |
+| AST available | No | Yes |
+| COPY expansion | Yes (pre-processing step) | N/A |
+| Deep indexing | Data items, SQL, CICS, FD, ENTRY | Type annotations, generics, etc. |
+| Call extraction | PERFORM (intra-file) + CALL (cross-program) | AST-based call site detection |
+| Import extraction | COPY statements | `import`/`require`/`use`/`#include` |
+| Coverage | All critical symbols | Language-dependent query coverage |
+| Failure mode | Never hangs | External scanner can hang (COBOL only) |
+
+## Sub-Documents
+
+| Document | Description |
+|----------|-------------|
+| [File Detection](./file-detection.md) | Extension mapping, `GITNEXUS_COBOL_DIRS`, copybook classification |
+| [COPY Expansion](./copy-expansion.md) | Copybook inlining, REPLACING transformations, cycle detection |
+| [Regex Extraction](./regex-extraction.md) | State machine, regex patterns, line processing |
+| [Deep Indexing](./deep-indexing.md) | Data items, EXEC SQL/CICS, file declarations, FD, ENTRY, MOVE |
+| [Graph Model](./graph-model.md) | COBOL-specific node types, edge types, full annotated example |
+| [Performance](./performance.md) | Benchmarks, worker pool tuning, caps, troubleshooting |
+
+## Key Source Files
+
+| File | Purpose |
+|------|---------|
+| `gitnexus/src/core/ingestion/cobol-preprocessor.ts` | Patch marker cleanup + regex extraction engine |
+| `gitnexus/src/core/ingestion/cobol-copy-expander.ts` | COPY statement expansion with REPLACING |
+| `gitnexus/src/core/ingestion/utils.ts` | `getLanguageFromPath`, `getLanguageFromFilename` |
+| `gitnexus/src/core/ingestion/pipeline.ts` | `isCobolCopybook`, `expandCobolCopies`, `detectCrossProgamContracts` |
+| `gitnexus/src/core/ingestion/workers/parse-worker.ts` | `processCobolRegexOnly` -- graph model builder |
+| `gitnexus/src/core/ingestion/workers/worker-pool.ts` | Configurable sub-batch size for COBOL |

docs/code-indexing/cobol/copy-expansion.md

@@ -0,0 +1,157 @@
+# COBOL COPY Expansion
+
+The COPY statement is COBOL's include mechanism -- analogous to `#include` in C or `import` in modern languages. GitNexus expands COPY statements **before** regex extraction so that symbols defined inside copybooks (data items, paragraphs, etc.) are visible in the program's extracted graph.
+
+## Supported Syntax
+
+### Basic COPY
+
+```cobol
+COPY CPSESP.
+COPY "WORKGRID.CPY".
+```
+
+Inlines the content of the named copybook, replacing the COPY line(s).
+
+### COPY with REPLACING
+
+```cobol
+COPY CPSESP REPLACING "ANAZI-KEY" BY "LK-KEY".
+COPY CPSESP REPLACING LEADING "ESP-" BY "LK-ESP-"
+                       LEADING "KPSESPL" BY "LK-KPSESPL".
+COPY LINKAGE REPLACING TRAILING "-IN" BY "-OUT".
+```
+
+Three REPLACING types are supported:
+
+| Type         | Syntax                               | Behavior                                | Example                          |
+| ------------ | ------------------------------------ | --------------------------------------- | -------------------------------- |
+| **EXACT**    | `REPLACING "OLD" BY "NEW"`           | Replace exact identifier matches        | `ANAZI-KEY` becomes `LK-KEY`     |
+| **LEADING**  | `REPLACING LEADING "PFX-" BY "NEW-"` | Replace prefix on all COBOL identifiers | `ESP-NAME` becomes `LK-ESP-NAME` |
+| **TRAILING** | `REPLACING TRAILING "-IN" BY "-OUT"` | Replace suffix on all COBOL identifiers | `DATA-IN` becomes `DATA-OUT`     |
+
+Multiple REPLACING clauses can appear in a single COPY statement. They are applied in order to each COBOL identifier in the copybook content.
+
+### Multi-Line COPY
+
+COPY statements can span multiple lines (standard COBOL continuation rules apply):
+
+```cobol
+       COPY CPSESP REPLACING
+      -    LEADING "ESP-" BY "LK-ESP-"
+      -    LEADING "KPSESPL" BY "LK-KPSESPL".
+```
+
+Continuation lines (indicator `-` in column 7) are merged before COPY statement scanning.
+
+## Expansion Flow
+
+```mermaid
+sequenceDiagram
+    participant Pipeline
+    participant Expander as COPY Expander
+    participant Resolver
+    participant Reader
+
+    Pipeline->>Pipeline: Identify all COBOL files
+    Pipeline->>Pipeline: Classify copybooks vs programs
+    Pipeline->>Reader: Read all copybook content upfront
+    Reader-->>Pipeline: Copybook content map (name -> content)
+
+    loop For each source file in chunk
+        Pipeline->>Expander: expandCopies(content, filePath, resolveFile, readFile)
+        Expander->>Expander: Merge continuation lines
+        Expander->>Expander: Detect COPY statements via regex
+
+        loop For each COPY statement (reverse order)
+            Expander->>Resolver: resolveFile(copyTarget)
+            Resolver-->>Expander: Copybook key or null
+
+            alt Resolved successfully
+                Expander->>Reader: readFile(resolvedKey)
+                Reader-->>Expander: Copybook content
+
+                Expander->>Expander: Apply REPLACING transformations
+                Expander->>Expander: Recurse for nested COPYs (depth + 1)
+                Expander->>Expander: Splice expanded content into output
+            else Not resolved
+                Expander->>Expander: Keep original COPY line
+            end
+        end
+
+        Expander-->>Pipeline: Expanded content + resolution metadata
+        Pipeline->>Pipeline: Replace file content with expanded content
+    end
+```
+
+The return type `CopyExpansionResult` contains `expandedContent` and `copyResolutions`. The `expansionDepth` field has been removed from the return type (it was unused by callers).
+
+COPY statement line numbers in `CopyResolution` are 1-based (consistent with the preprocessor's line numbering). The splice operation that replaces COPY lines with expanded content adjusts for 0-based array indexing internally.
+
+## Cycle Detection
+
+Circular COPY references (e.g., copybook A includes copybook B which includes copybook A) are detected and handled:
+
+1. Each expansion chain maintains a `visited` set of resolved copybook paths
+2. If a copybook path is already in the visited set, the expansion is skipped
+3. A `warnedCircular` set (internal to `expandCopies()`, not a parameter) deduplicates warning messages within a single file expansion
+
+Known circular copybooks in PROJECT-NAME: `ANAZI`, `ANDIP`, `QDIPE` (self-referential includes).
+
+## Max Depth
+
+Nested COPY expansion is limited to **10 levels** (`DEFAULT_MAX_DEPTH`). If a COPY chain exceeds this depth, a warning is logged and the remaining COPY statements are left unexpanded.
+
+## Max Total Expansions
+
+A breadth amplification guard caps the total number of COPY expansions across all branches within a single file to **500** (`MAX_TOTAL_EXPANSIONS`). This prevents exponential blowup from diamond-shaped COPY graphs where N copybooks each include N other copybooks. Once the limit is reached, further COPY statements in that file are left unexpanded and a single warning is logged.
+
+## REPLACING Application Detail
+
+The REPLACING engine works by scanning all COBOL identifiers (matching `\b[A-Z][A-Z0-9-]*\b`) in the copybook content and applying each replacement rule:
+
+```
+Original copybook content:
+       05  ESP-NAME          PIC X(30).
+       05  ESP-CODE          PIC X(10).
+       05  KPSESPL-FLAG      PIC X(01).
+
+After REPLACING LEADING "ESP-" BY "LK-ESP-" LEADING "KPSESPL" BY "LK-KPSESPL":
+       05  LK-ESP-NAME       PIC X(30).
+       05  LK-ESP-CODE       PIC X(10).
+       05  LK-KPSESPL-FLAG   PIC X(01).
+```
+
+For LEADING replacements, the engine checks if each identifier starts with the `from` prefix (case-insensitive) and replaces only the prefix portion, preserving the rest of the identifier.
+
+For TRAILING replacements, the same logic applies to suffixes.
+
+For EXACT replacements, only identifiers that match the `from` value exactly (case-insensitive) are replaced.
+
+## Copybook Resolution
+
+The resolver tries multiple strategies to match a COPY target name to a copybook file:
+
+1. **Exact match**: `COPY CPSESP` resolves to copybook named `CPSESP`
+2. **Strip extension**: `COPY WORKGRID.CPY` strips `.CPY` and resolves to `WORKGRID`
+3. **Add extension**: `COPY CPSESP` tries `CPSESP.CPY` and `CPSESP.COPY`
+
+If no match is found, the COPY statement is left in place (unexpanded) and a resolution record with `resolvedPath: null` is created.
+
+## Pipeline Integration
+
+The expansion runs **per chunk**, after file content is read but before dispatch to worker threads:
+
+1. All copybook files are read upfront (they are typically small, collectively under 100MB)
+2. Per chunk, the copybook map is merged with chunk content (in case a chunk contains copybooks)
+3. Only programs (not copybooks themselves) undergo expansion
+4. The expanded content replaces the original content in-place before worker dispatch
+
+## Inline Comment Handling
+
+The copy expander's `stripInlineComment()` helper is quote-aware: pipe characters (`|`) inside single- or double-quoted strings are preserved. This matches the same quote-aware logic used by the preprocessor.
+
+## Source Files
+
+- `gitnexus/src/core/ingestion/cobol-copy-expander.ts` -- `expandCopies()`, `parseReplacingClause()`, `applyReplacing()`
+- `gitnexus/src/core/ingestion/pipeline.ts` -- `expandCobolCopies()`, copybook map construction, chunk integration

docs/code-indexing/cobol/deep-indexing.md

@@ -0,0 +1,312 @@
+# COBOL Deep Indexing
+
+Beyond basic symbol extraction (program name, paragraphs, CALL, PERFORM, COPY), GitNexus performs deep indexing of COBOL-specific constructs: data items, EXEC SQL/CICS blocks, file declarations, FD entries, ENTRY points, and MOVE statements.
+
+## Data Items
+
+### Level Numbers
+
+| Level Range | Meaning | Graph Node Type |
+|-------------|---------|-----------------|
+| 01 | Record (group item) | `Record` |
+| 02-49 | Elementary/group items | `Property` |
+| 66 | RENAMES | `Property` |
+| 77 | Independent item | `Property` |
+| 88 | Condition name | `Const` |
+
+FILLER items are skipped (no useful name for the graph).
+
+### Clauses Parsed
+
+The `parseDataItemClauses()` function extracts these clauses from the trailing text of a data item declaration:
+
+| Clause | Pattern | Example |
+|--------|---------|---------|
+| `PIC` / `PICTURE` | `\bPIC(?:TURE)?\s+(?:IS\s+)?(\S+)` | `PIC X(30)`, `PICTURE IS 9(5)V99` |
+| `USAGE` | `\bUSAGE\s+(?:IS\s+)?(COMP\|BINARY\|...)` | `USAGE IS COMP-3`, `BINARY` |
+| `REDEFINES` | `\bREDEFINES\s+([A-Z][A-Z0-9-]+)` | `REDEFINES WK-DATE-NUM` |
+| `OCCURS` | `\bOCCURS\s+(\d+)` | `OCCURS 12 TIMES` |
+
+Standalone COMP variants (without the `USAGE` keyword) are also detected: `COMP`, `COMP-1` through `COMP-6`, `COMP-X`, `BINARY`, `PACKED-DECIMAL`.
+
+### Data Hierarchy
+
+Data items form a hierarchical structure based on level numbers. The extractor uses a **stack algorithm**:
+
+```
+Processing order:
+  01 WK-RECORD          -> push {01, WK-RECORD}   -> parent: Module
+  05 WK-NAME            -> push {05, WK-NAME}     -> parent: WK-RECORD (01 < 05)
+  10 WK-FIRST           -> push {10, WK-FIRST}    -> parent: WK-NAME (05 < 10)
+  10 WK-LAST            -> pop WK-FIRST, push      -> parent: WK-NAME (05 < 10)
+  05 WK-CODE            -> pop WK-LAST, WK-NAME    -> parent: WK-RECORD (01 < 05)
+  88 WK-ACTIVE          -> (88 handled separately)  -> parent: WK-CODE
+```
+
+The stack maintains items where each entry's level is strictly less than the next. When a new item arrives with a level <= the top of stack, items are popped until the stack top has a smaller level. A `CONTAINS` edge is created from the stack top to the new item.
+
+For 88-level condition names, the parent is the immediately preceding non-88 data item (found by scanning backwards).
+
+### Annotated Example
+
+```cobol
+       01  WK-EMPLOYEE.
+           05  WK-EMP-ID          PIC 9(6).
+           05  WK-EMP-NAME        PIC X(30).
+           05  WK-EMP-STATUS      PIC X(01).
+               88  WK-ACTIVE      VALUE "A".
+               88  WK-INACTIVE    VALUE "I".
+           05  WK-SALARY          PIC 9(7)V99 COMP-3.
+           05  WK-DEPT            PIC X(04) OCCURS 3 TIMES.
+```
+
+Produces:
+- `Record` node: `WK-EMPLOYEE` (level 01, section: working-storage)
+- `Property` nodes: `WK-EMP-ID`, `WK-EMP-NAME`, `WK-EMP-STATUS`, `WK-SALARY`, `WK-DEPT`
+- `Const` nodes: `WK-ACTIVE` (values: `A`), `WK-INACTIVE` (values: `I`)
+- `CONTAINS` edges: `WK-EMPLOYEE -> WK-EMP-ID`, `WK-EMPLOYEE -> WK-EMP-NAME`, etc.
+- `CONTAINS` edges: `WK-EMP-STATUS -> WK-ACTIVE`, `WK-EMP-STATUS -> WK-INACTIVE`
+
+### Data Item Cap
+
+A maximum of **500 data items per file** (`MAX_DATA_ITEMS_PER_FILE`) are processed. Some COBOL programs (especially after COPY expansion) can have 10,000+ data items, which would cause graph bloat and push the V8 relationship Map past its 16.7M entry limit across thousands of files.
+
+The cap applies after extraction: the first 500 items in source order are kept. Since 01-level records appear first, critical top-level structure is preserved.
+
+## EXEC SQL
+
+EXEC SQL blocks are accumulated across lines between `EXEC SQL` and `END-EXEC`, then parsed as a unit.
+
+### Operation Classification
+
+The first SQL keyword determines the operation:
+
+| First Keyword | Operation |
+|---------------|-----------|
+| `SELECT` | SELECT |
+| `INSERT` | INSERT |
+| `UPDATE` | UPDATE |
+| `DELETE` | DELETE |
+| `DECLARE` | DECLARE |
+| `OPEN` | OPEN |
+| `CLOSE` | CLOSE |
+| `FETCH` | FETCH |
+| *(anything else)* | OTHER |
+
+### Table Extraction
+
+Tables are extracted from SQL clauses:
+
+| Clause Pattern | Example |
+|----------------|---------|
+| `FROM <table>` | `SELECT * FROM EMPLOYEES` |
+| `INSERT INTO <table>` | `INSERT INTO EMPLOYEES` |
+| `UPDATE <table>` | `UPDATE EMPLOYEES SET ...` |
+| `JOIN <table>` | `LEFT JOIN DEPARTMENTS ON ...` |
+
+Note: The `INTO` pattern is restricted to `INSERT INTO` to avoid false positives from `FETCH ... INTO :host-var` and `SELECT ... INTO :host-var` statements, where `INTO` introduces host variables rather than table names.
+
+### Cursor Detection
+
+```cobol
+           EXEC SQL
+               DECLARE C-EMPLOYEES CURSOR FOR
+               SELECT EMP-ID, EMP-NAME FROM EMPLOYEES
+               WHERE DEPT = :WK-DEPT
+           END-EXEC
+```
+
+Extracts: cursor `C-EMPLOYEES`, table `EMPLOYEES`, host variable `WK-DEPT`.
+
+### Host Variables
+
+Host variables are COBOL variables referenced in SQL with a `:` prefix. The colon is stripped:
+
+```sql
+WHERE EMP-ID = :WK-EMP-ID AND DEPT = :WK-DEPT
+```
+
+Extracts: `WK-EMP-ID`, `WK-DEPT`.
+
+### Graph Output
+
+- `CodeElement` node per table, with description `sql-table op:{OP}`
+- `CodeElement` node per cursor, with description `sql-cursor`
+- `ACCESSES` edge from Module to each CodeElement
+- Deduplication: if the same table appears in multiple SQL blocks, only one node is created
+
+## EXEC CICS
+
+EXEC CICS blocks are accumulated and parsed similarly to SQL blocks.
+
+### Command Detection
+
+Two-word commands are detected first (matched against the block start):
+
+```
+SEND MAP, RECEIVE MAP, SEND TEXT, SEND CONTROL, READ NEXT, READ PREV
+```
+
+If no two-word command matches, the first word is used (e.g., `LINK`, `XCTL`, `RETURN`, `READ`, `WRITE`).
+
+### Extraction
+
+| Element | Pattern | Example |
+|---------|---------|---------|
+| MAP name | `MAP('name')` or `MAP("name")` | `EXEC CICS SEND MAP('EMPMENU')` |
+| PROGRAM name | `PROGRAM('name')` or `PROGRAM("name")` | `EXEC CICS LINK PROGRAM('BGTABUP')` |
+| TRANSID | `TRANSID('name')` or `TRANSID("name")` | `EXEC CICS START TRANSID('EMP1')` |
+
+### Graph Output
+
+- MAP: `CodeElement` node with description `cics-map cmd:{CMD}` + `ACCESSES` edge from Module
+- PROGRAM: `CALLS` edge (cross-program call via CICS LINK/XCTL)
+- TRANSID: `CodeElement` node with description `cics-transid cmd:{CMD}` + `ACCESSES` edge from Module
+
+### Annotated Example
+
+```cobol
+           EXEC CICS
+               SEND MAP('EMPMENU')
+               MAPSET('EMPSET')
+               FROM(WK-MAP-DATA)
+               ERASE
+           END-EXEC
+```
+
+Produces:
+- `CodeElement` node: `EMPMENU` (description: `cics-map cmd:SEND MAP`)
+- `ACCESSES` edge: Module -> `EMPMENU`
+
+## File Declarations
+
+SELECT statements in the INPUT-OUTPUT SECTION are accumulated across multiple lines (until a period terminator) and parsed for:
+
+| Clause | Pattern | Example |
+|--------|---------|---------|
+| SELECT | `SELECT <name>` | `SELECT MASTER-FILE` |
+| ASSIGN | `ASSIGN TO <file>` | `ASSIGN TO "MASTER.DAT"` |
+| ORGANIZATION | `ORGANIZATION IS <type>` | `ORGANIZATION IS INDEXED` |
+| ACCESS | `ACCESS MODE IS <mode>` | `ACCESS MODE IS DYNAMIC` |
+| RECORD KEY | `RECORD KEY IS <field>` | `RECORD KEY IS WK-EMP-ID` |
+| FILE STATUS | `FILE STATUS IS <field>` | `FILE STATUS IS WK-FILE-STATUS` |
+
+### Graph Output
+
+- `CodeElement` node with description containing all parsed clauses (e.g., `select org:INDEXED access:DYNAMIC key:WK-EMP-ID status:WK-FILE-STATUS assign:MASTER.DAT`)
+- `RECORD_KEY_OF` edge: from Property node to CodeElement (confidence 0.8)
+- `FILE_STATUS_OF` edge: from Property node to CodeElement (confidence 0.8)
+
+## FD Entries
+
+FD (File Description) entries associate a file name with its record layout:
+
+```cobol
+       FD  MASTER-FILE.
+       01  MASTER-RECORD.
+           05  MR-EMP-ID       PIC 9(6).
+           05  MR-EMP-NAME     PIC X(30).
+```
+
+The extractor tracks `pendingFdName` state: when an `FD` line is seen, the next 01-level data item becomes its record.
+
+### Graph Output
+
+- `CodeElement` node with description `fd record:{recordName}`
+- `CONTAINS` edge: FD CodeElement -> Record node
+- `CONTAINS` edge: SELECT CodeElement -> FD CodeElement (linking file declaration to file description)
+
+## ENTRY Points
+
+The `ENTRY` statement defines additional entry points into a COBOL program (in addition to the main program entry):
+
+```cobol
+       ENTRY "SUBPROG" USING WK-PARAM-1 WK-PARAM-2.
+```
+
+### Graph Output
+
+- `Constructor` node with description `entry params:{param1},{param2}` (or just `entry` if no parameters)
+- `CONTAINS` edge: Module -> Constructor
+- Symbol table entry (so the entry point is discoverable by name)
+
+## PROCEDURE DIVISION USING
+
+```cobol
+       PROCEDURE DIVISION USING WK-INPUT-REC WK-OUTPUT-REC.
+```
+
+The USING clause identifies parameters received by the program from its caller.
+
+### Graph Output
+
+- `RECEIVES` edge: Module -> Property (for each parameter name, confidence 0.8)
+
+## MOVE Statements
+
+MOVE statements produce `ACCESSES` edges in the graph:
+
+```cobol
+       MOVE WK-NAME TO OUT-NAME.
+       MOVE CORRESPONDING WK-INPUT TO WK-OUTPUT.
+       MOVE CORR WK-IN TO WK-OUT.
+```
+
+### Extraction Details
+
+- Source and target identifiers are captured
+- `CORRESPONDING` and its abbreviation `CORR` are both recognized (bulk field-by-field move)
+- Figurative constants (SPACES, ZEROS, LOW-VALUES, HIGH-VALUES, QUOTES, ALL) are skipped
+- The enclosing paragraph (`caller`) is tracked for context
+
+### MOVE CORRESPONDING / CORR Edge Reasons
+
+MOVE CORRESPONDING (and CORR) produces distinct edge reasons to differentiate from simple MOVE:
+
+| Edge | Reason (simple MOVE) | Reason (CORRESPONDING/CORR) |
+|------|---------------------|-----------------------------|
+| Read (source) | `cobol-move-read` | `cobol-move-corresponding-read` |
+| Write (target) | `cobol-move-write` | `cobol-move-corresponding-write` |
+
+This distinction allows queries to find bulk field-by-field moves separately from simple variable assignments.
+
+## GO TO DEPENDING ON
+
+The `GO TO` statement with multiple targets and a `DEPENDING ON` clause is a computed branch:
+
+```cobol
+       GO TO PARA-1 PARA-2 PARA-3
+           DEPENDING ON WK-SELECTOR.
+```
+
+All target paragraph names are extracted and emitted as separate `gotos` entries. Each target produces a `CALLS` edge in the graph (same semantics as PERFORM). The `DEPENDING ON` variable is not currently tracked as a data-flow dependency.
+
+## SORT INPUT/OUTPUT PROCEDURE
+
+SORT and MERGE statements can specify procedural entry points instead of file-based I/O:
+
+```cobol
+       SORT SORT-FILE ON ASCENDING KEY SORT-KEY
+           INPUT PROCEDURE IS PREPARE-INPUT
+           OUTPUT PROCEDURE IS FORMAT-OUTPUT.
+```
+
+`INPUT PROCEDURE IS` and `OUTPUT PROCEDURE IS` targets are extracted as control-flow targets (same as PERFORM). They produce `performs` entries and corresponding `CALLS` edges in the graph.
+
+## Fixed-Format Literal Continuation
+
+In fixed-format COBOL, string literals can span multiple lines using the continuation indicator (`-` in column 7). When a continuation line starts with a quote character, the extractor joins it with the predecessor by removing the trailing quote from the previous line and the opening quote from the continuation:
+
+```
+Line N:          MOVE "THIS IS A LONG STRI
+Line N+1 (cont): -    "NG VALUE" TO WK-FIELD.
+Merged:          MOVE "THIS IS A LONG STRING VALUE" TO WK-FIELD.
+```
+
+The trailing `"` on line N and the opening `"` on line N+1 are both removed, producing a seamless literal. If no matching quote is found on the predecessor line, the continuation is appended as-is.
+
+## Source Files
+
+- `gitnexus/src/core/ingestion/cobol-preprocessor.ts` -- All extraction logic, clause parsers, EXEC block parsers
+- `gitnexus/src/core/ingestion/workers/parse-worker.ts` -- `processCobolRegexOnly()`, graph node/edge emission
+- `gitnexus/src/core/ingestion/parsing-processor.ts` -- Sequential fallback with same `MAX_DATA_ITEMS_PER_FILE` cap

docs/code-indexing/cobol/file-detection.md

@@ -0,0 +1,126 @@
+# COBOL File Detection
+
+GitNexus detects COBOL files through two mechanisms: extension-based mapping and directory-based override for extensionless files. This document covers both, plus the copybook/program classification logic.
+
+## Extension Mapping
+
+### Program Extensions
+
+| Extension | Type |
+|-----------|------|
+| `.cbl` | COBOL program |
+| `.cob` | COBOL program |
+| `.cobol` | COBOL program |
+
+### Copybook Extensions
+
+| Extension | Type | Notes |
+|-----------|------|-------|
+| `.cpy` | Copybook | Standard |
+| `.copy` | Copybook | Standard |
+| `.gnm` / `.GNM` | Copybook | Enterprise (GnuCOBOL naming) |
+| `.fd` / `.FD` | Copybook | File Description fragment |
+| `.wrk` / `.WRK` | Copybook | Working-Storage fragment |
+| `.sel` / `.SEL` | Copybook | SELECT clause fragment |
+| `.open` / `.OPEN` | Copybook | File OPEN fragment |
+| `.close` / `.CLOSE` | Copybook | File CLOSE fragment |
+| `.ini` / `.INI` | Copybook | Initialization fragment |
+| `.def` / `.DEF` | Copybook | Definition fragment |
+
+All extension matching is case-sensitive in `getLanguageFromFilename` (the extensions above are matched as written, including uppercase variants like `.GNM`).
+
+## Extensionless File Detection: `GITNEXUS_COBOL_DIRS`
+
+Many enterprise COBOL repositories use extensionless files -- the filename alone identifies the program (e.g., `s/BGTABFL` is the source for program `BGTABFL`). GitNexus handles this via the `GITNEXUS_COBOL_DIRS` environment variable.
+
+### Configuration
+
+Set `GITNEXUS_COBOL_DIRS` to a comma-separated list of directory names:
+
+```bash
+# Files in s/, c/, and wfproc/ directories (at any depth) are treated as COBOL
+export GITNEXUS_COBOL_DIRS=s,c,wfproc
+```
+
+The matching is **case-insensitive** and checks all path segments:
+
+- `/repo/s/BGTABFL` -- matches segment `s` -- COBOL
+- `/repo/src/c/CPSESP` -- matches segment `c` -- COBOL
+- `/repo/wfproc/WF001` -- matches segment `wfproc` -- COBOL
+- `/repo/docs/README` -- no matching segment -- skipped
+
+### Decision Tree
+
+```mermaid
+flowchart TD
+    A[getLanguageFromPath] --> B[getLanguageFromFilename]
+    B --> C{Known extension?}
+    C -->|Yes .cbl/.cob/.cobol/.cpy/...| D[Return COBOL]
+    C -->|Yes .ts/.py/.java/...| E[Return other language]
+    C -->|No match| F{Has extension?}
+
+    F -->|"Has dot in basename"| G[Return null]
+    F -->|"No dot = extensionless"| H{GITNEXUS_COBOL_DIRS set?}
+
+    H -->|No| G
+    H -->|Yes| I{Any path segment<br/>matches a configured dir?}
+
+    I -->|Yes| D
+    I -->|No| G
+
+    style D fill:#e8f5e9,stroke:#2e7d32
+    style G fill:#ffebee,stroke:#c62828
+```
+
+### Implementation Detail
+
+The `GITNEXUS_COBOL_DIRS` value is parsed once (on first call) and cached in a `Set<string>`:
+
+```typescript
+// From gitnexus/src/core/ingestion/utils.ts
+const getCobolDirs = (): Set<string> => {
+  if (_cobolDirs) return _cobolDirs;
+  const raw = process.env.GITNEXUS_COBOL_DIRS;
+  _cobolDirs = raw
+    ? new Set(raw.split(',').map(d => d.trim().toLowerCase()))
+    : new Set();
+  return _cobolDirs;
+};
+```
+
+The path segment check splits the full path on `/` and tests each segment against the cached set.
+
+## Copybook vs Program Classification
+
+After a file is identified as COBOL, it must be classified as either a **program** (to be parsed for symbols) or a **copybook** (to be loaded into the copybook map for COPY expansion).
+
+### Classification Rules
+
+A COBOL file is classified as a **copybook** if ANY of these conditions is true:
+
+1. It has a recognized copybook extension (`.cpy`, `.copy`, `.gnm`, `.fd`, `.wrk`, `.sel`, `.open`, `.close`, `.ini`, `.def`)
+2. It is an extensionless file whose path contains a directory segment matching one of: `c`, `copy`, `copybooks`, `copylib`, `cpy`
+
+A file is classified as a **program** if:
+
+1. It has a program extension (`.cbl`, `.cob`, `.cobol`), OR
+2. It is extensionless and does NOT match any copybook directory pattern
+
+### Copybook Name Resolution
+
+Copybook names are derived from the filename:
+
+- Strip the extension (if any)
+- Convert to uppercase
+
+Examples:
+- `c/CPSESP` -- name: `CPSESP`
+- `copy/workgrid.cpy` -- name: `WORKGRID`
+- `c/ANAZI.GNM` -- name: `ANAZI`
+
+This name is used to resolve `COPY CPSESP.` statements during expansion.
+
+## Source Files
+
+- `gitnexus/src/core/ingestion/utils.ts` -- `getLanguageFromPath()`, `getLanguageFromFilename()`, `getCobolDirs()`
+- `gitnexus/src/core/ingestion/pipeline.ts` -- `isCobolCopybook()`, `getCopybookName()`, `COPYBOOK_EXTENSIONS`, `COBOL_PROGRAM_EXTENSIONS`

docs/code-indexing/cobol/graph-model.md

@@ -0,0 +1,193 @@
+# COBOL Graph Model
+
+This document describes the graph nodes and edges that GitNexus creates for COBOL codebases. The COBOL graph model is richer than most tree-sitter languages because it captures domain-specific constructs: file declarations, FD entries, data hierarchies, SQL tables, CICS maps, and cross-program contracts.
+
+## Entity-Relationship Diagram
+
+```mermaid
+erDiagram
+    File ||--o{ Module : DEFINES
+    File ||--o{ Function : DEFINES
+    File ||--o{ Namespace : DEFINES
+    File ||--o{ Record : DEFINES
+    File ||--o{ Property : DEFINES
+    File ||--o{ Const : DEFINES
+    File ||--o{ CodeElement : DEFINES
+    File ||--o{ Constructor : DEFINES
+    File }o--o{ File : IMPORTS
+
+    Module ||--o{ Record : CONTAINS
+    Module ||--o{ Constructor : CONTAINS
+    Module }o--o{ CodeElement : ACCESSES
+    Module }o--o{ Module : CALLS
+    Module }o--o{ Module : CONTRACTS
+    Module }o--o{ Property : RECEIVES
+
+    Record ||--o{ Property : CONTAINS
+    Record ||--o{ Const : CONTAINS
+    Record }o--o{ Record : REDEFINES
+
+    Property ||--o{ Property : CONTAINS
+    Property ||--o{ Const : CONTAINS
+    Property }o--o{ Property : REDEFINES
+    Property }o--o{ CodeElement : RECORD_KEY_OF
+    Property }o--o{ CodeElement : FILE_STATUS_OF
+
+    CodeElement ||--o{ CodeElement : CONTAINS
+    CodeElement ||--o{ Record : CONTAINS
+
+    Function }o--o{ Function : CALLS
+```
+
+## Node Types
+
+| Node Type | COBOL Concept | Created From | Example |
+|-----------|--------------|--------------|---------|
+| `Module` | PROGRAM-ID | `PROGRAM-ID. BGTABFL` | Name: `BGTABFL`, description may include author and date |
+| `Function` | Paragraph | `PROCESS-RECORD.` at column 8 | Name: `PROCESS-RECORD` |
+| `Namespace` | Procedure section | `MAIN-LOGIC SECTION.` at column 8 | Name: `MAIN-LOGIC` |
+| `Record` | 01-level data item | `01 WK-EMPLOYEE.` | Description: `level:01 section:working-storage` |
+| `Property` | 02-49/66/77 data item | `05 WK-NAME PIC X(30).` | Description: `level:05 pic:X(30) section:working-storage` |
+| `Const` | 88-level condition | `88 WK-ACTIVE VALUE "A".` | Description: `level:88 values:A` |
+| `CodeElement` | SELECT, FD, SQL table, CICS map, cursor, transid | Various | Description varies by subtype |
+| `Constructor` | ENTRY point | `ENTRY "SUBPROG" USING WK-DATA` | Description: `entry params:WK-DATA` |
+
+### CodeElement Subtypes
+
+CodeElement is used for multiple COBOL constructs, distinguished by their description prefix:
+
+| Subtype | ID Pattern | Description Format | Example |
+|---------|-----------|-------------------|---------|
+| File SELECT | `CodeElement:{path}:SELECT:{name}` | `select org:INDEXED access:DYNAMIC ...` | `SELECT MASTER-FILE` |
+| FD entry | `CodeElement:{path}:FD:{name}` | `fd record:{recordName}` | `FD MASTER-FILE` |
+| SQL table | `CodeElement:{path}:sql-table:{name}` | `sql-table op:SELECT` | Table `EMPLOYEES` |
+| SQL cursor | `CodeElement:{path}:sql-cursor:{name}` | `sql-cursor` | Cursor `C-EMPLOYEES` |
+| CICS map | `CodeElement:{path}:cics-map:{name}` | `cics-map cmd:SEND MAP` | Map `EMPMENU` |
+| CICS transid | `CodeElement:{path}:cics-transid:{name}` | `cics-transid cmd:START` | Transid `EMP1` |
+
+## Edge Types
+
+| Edge Type | Source | Target | Created By | Confidence | Example |
+|-----------|--------|--------|-----------|------------|---------|
+| `DEFINES` | File | any node | File defines its symbols | 1.0 | File -> Module `BGTABFL` |
+| `CALLS` | Function | Function | `PERFORM X [THRU Y]` | (via call-processor) | `PROCESS-RECORD` -> `CALC-TAX` |
+| `CALLS` | Module | Module | `CALL "BGTABUP"` | (via call-processor) | `BGTABFL` -> `BGTABUP` |
+| `CALLS` | Module | Module | `EXEC CICS LINK PROGRAM('X')` | (via call-processor) | `BGTABFL` -> `BGTABUP` |
+| `IMPORTS` | File | File | `COPY copybook` | (via import-processor) | Source file -> Copybook file |
+| `CONTAINS` | Module | Record | Data hierarchy root | 1.0 | `BGTABFL` -> `WK-EMPLOYEE` |
+| `CONTAINS` | Record | Property | Data hierarchy | 1.0 | `WK-EMPLOYEE` -> `WK-NAME` |
+| `CONTAINS` | Property | Property | Nested data items | 1.0 | `WK-ADDRESS` -> `WK-CITY` |
+| `CONTAINS` | Record/Property | Const | 88-level parent | 1.0 | `WK-STATUS` -> `WK-ACTIVE` |
+| `CONTAINS` | CodeElement (FD) | Record | FD record link | 1.0 | `FD:MASTER-FILE` -> `MASTER-RECORD` |
+| `CONTAINS` | CodeElement (SELECT) | CodeElement (FD) | SELECT-FD link | 0.9 | `SELECT:MASTER-FILE` -> `FD:MASTER-FILE` |
+| `CONTAINS` | Module | Constructor | ENTRY in module | 1.0 | `BGTABFL` -> `SUBPROG` |
+| `REDEFINES` | Record | Record | `01 X REDEFINES Y` | 1.0 | `WK-DATE-NUM` -> `WK-DATE-ALPHA` |
+| `REDEFINES` | Property | Property | `05 X REDEFINES Y` | 1.0 | `WK-CODE-NUM` -> `WK-CODE-ALPHA` |
+| `RECORD_KEY_OF` | Property | CodeElement (SELECT) | `RECORD KEY IS field` | 0.8 | `WK-EMP-ID` -> `SELECT:MASTER-FILE` |
+| `FILE_STATUS_OF` | Property | CodeElement (SELECT) | `FILE STATUS IS field` | 0.8 | `WK-FS` -> `SELECT:MASTER-FILE` |
+| `ACCESSES` | Module | CodeElement | EXEC SQL/CICS | 0.9 | `BGTABFL` -> `sql-table:EMPLOYEES` |
+| `RECEIVES` | Module | Property | `PROCEDURE USING` | 0.8 | `BGTABFL` -> `WK-INPUT-REC` |
+| `CONTRACTS` | Module | Module | Shared copybook detection | 0.9 | `BGTABFL` -> `BGTABUP` (via `CPSESP`) |
+
+## Full Annotated Example
+
+Given this COBOL program:
+
+```cobol
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. EMPMAINT.
+       AUTHOR. Development Team.
+
+       ENVIRONMENT DIVISION.
+       INPUT-OUTPUT SECTION.
+       FILE-CONTROL.
+           SELECT EMP-FILE
+               ASSIGN TO "EMPLOYEE.DAT"
+               ORGANIZATION IS INDEXED
+               ACCESS MODE IS DYNAMIC
+               RECORD KEY IS EMP-ID
+               FILE STATUS IS WS-FILE-STATUS.
+
+       DATA DIVISION.
+       FILE SECTION.
+       FD  EMP-FILE.
+       01  EMP-RECORD.
+           05  EMP-ID             PIC 9(6).
+           05  EMP-NAME           PIC X(30).
+
+       WORKING-STORAGE SECTION.
+       01  WS-FLAGS.
+           05  WS-FILE-STATUS     PIC X(02).
+           05  WS-EOF-FLAG        PIC X(01).
+               88  WS-EOF         VALUE "Y".
+
+       LINKAGE SECTION.
+       01  LK-SEARCH-KEY          PIC 9(6).
+
+       PROCEDURE DIVISION USING LK-SEARCH-KEY.
+       MAIN-LOGIC SECTION.
+       MAIN-START.
+           PERFORM OPEN-FILE
+           PERFORM PROCESS-RECORDS
+           PERFORM CLOSE-FILE
+           STOP RUN.
+
+       OPEN-FILE.
+           OPEN I-O EMP-FILE.
+
+       PROCESS-RECORDS.
+           MOVE LK-SEARCH-KEY TO EMP-ID
+           EXEC SQL
+               SELECT EMP_SALARY INTO :WS-SALARY
+               FROM EMPLOYEES
+               WHERE EMP_ID = :EMP-ID
+           END-EXEC
+           CALL "EMPREPORT".
+
+       CLOSE-FILE.
+           CLOSE EMP-FILE.
+```
+
+The graph produced contains:
+
+**Nodes:**
+- `Module`: EMPMAINT (description: `author:Development Team`)
+- `Namespace`: MAIN-LOGIC
+- `Function`: MAIN-START, OPEN-FILE, PROCESS-RECORDS, CLOSE-FILE
+- `Record`: EMP-RECORD, WS-FLAGS, LK-SEARCH-KEY
+- `Property`: EMP-ID, EMP-NAME, WS-FILE-STATUS, WS-EOF-FLAG
+- `Const`: WS-EOF (values: Y)
+- `CodeElement`: SELECT:EMP-FILE, FD:EMP-FILE, sql-table:EMPLOYEES
+- (COPY imports, if any, would produce File IMPORTS edges)
+
+**Edges:**
+- `DEFINES`: File -> all nodes
+- `CONTAINS`: EMPMAINT -> EMP-RECORD, EMPMAINT -> WS-FLAGS, EMPMAINT -> LK-SEARCH-KEY
+- `CONTAINS`: EMP-RECORD -> EMP-ID, EMP-RECORD -> EMP-NAME
+- `CONTAINS`: WS-FLAGS -> WS-FILE-STATUS, WS-FLAGS -> WS-EOF-FLAG
+- `CONTAINS`: WS-EOF-FLAG -> WS-EOF
+- `CONTAINS`: FD:EMP-FILE -> EMP-RECORD
+- `CONTAINS`: SELECT:EMP-FILE -> FD:EMP-FILE
+- `CALLS`: MAIN-START -> OPEN-FILE, MAIN-START -> PROCESS-RECORDS, MAIN-START -> CLOSE-FILE
+- `CALLS`: EMPMAINT -> EMPREPORT (external CALL)
+- `ACCESSES`: EMPMAINT -> sql-table:EMPLOYEES
+- `RECEIVES`: EMPMAINT -> LK-SEARCH-KEY (PROCEDURE USING)
+- `RECORD_KEY_OF`: EMP-ID -> SELECT:EMP-FILE
+- `FILE_STATUS_OF`: WS-FILE-STATUS -> SELECT:EMP-FILE
+
+## How COBOL Differs from Tree-Sitter Languages
+
+| Aspect | COBOL | Tree-Sitter Languages |
+|--------|-------|----------------------|
+| Node variety | 8 types (Module, Function, Namespace, Record, Property, Const, CodeElement, Constructor) | Typically 4-6 (Function, Class, Method, Interface, Module, Const) |
+| Domain edges | RECORD_KEY_OF, FILE_STATUS_OF, ACCESSES, RECEIVES, CONTRACTS, REDEFINES | Primarily CALLS, IMPORTS, EXTENDS, IMPLEMENTS |
+| Data hierarchy | Deep CONTAINS chains (01 -> 05 -> 10 -> 88) | Flat class members |
+| Cross-program calls | CALL "name" + CICS LINK PROGRAM | Import-based resolution |
+| Contract detection | Shared COPY copybook between caller/callee | Not applicable |
+| Metadata | AUTHOR, DATE-WRITTEN on Module | JSDoc/docstring (not indexed) |
+
+## Source Files
+
+- `gitnexus/src/core/ingestion/workers/parse-worker.ts` -- `processCobolRegexOnly()`, node/edge emission logic
+- `gitnexus/src/core/ingestion/pipeline.ts` -- `detectCrossProgamContracts()` for CONTRACTS edges
+- `gitnexus/src/core/ingestion/cobol-preprocessor.ts` -- `CobolRegexResults` interface (all extracted data)

docs/code-indexing/cobol/performance.md

@@ -0,0 +1,261 @@
+# COBOL Performance and Tuning
+
+This document covers real-world benchmarks, worker pool configuration, memory management, known limitations, and troubleshooting for COBOL indexing.
+
+## PROJECT-NAME Benchmark
+
+The PROJECT-NAME project is a large Italian payroll system written in COBOL. It serves as the primary benchmark for COBOL indexing performance.
+
+### Input
+
+| Metric                      | Value                                                                        |
+| --------------------------- | ---------------------------------------------------------------------------- |
+| Paths scanned               | 14,217                                                                       |
+| Parseable files             | 13,129                                                                       |
+| Total source size           | 224 MB                                                                       |
+| Chunks                      | 12 (at 20 MB budget)                                                         |
+| Copybooks loaded            | 2,976                                                                        |
+| Copybooks used in expansion | 2,955                                                                        |
+| Key directories             | `s/` (7773 programs), `c/` (3036 copybooks), `wfproc/` (1973 workflow files) |
+
+### Output
+
+| Metric                 | Value  |
+| ---------------------- | ------ |
+| Graph nodes            | 2.79M  |
+| Graph edges            | 5.67M  |
+| Clusters (communities) | 16,679 |
+| Execution flows        | 300    |
+
+### Timing
+
+| Phase                           | Duration          |
+| ------------------------------- | ----------------- |
+| Total                           | ~251s             |
+| KuzuDB write                    | 132s              |
+| Full-text search indexing       | 6.7s              |
+| Regex extraction (avg per file) | ~1ms              |
+| COPY expansion + deep indexing  | Remainder (~112s) |
+
+### Indexing Command
+
+```bash
+cd /path/to/PROJECT-NAME
+GITNEXUS_COBOL_DIRS=s,c,wfproc GITNEXUS_VERBOSE=1 node --max-old-space-size=8192 \
+  /path/to/gitnexus/dist/cli/index.js analyze --force
+```
+
+## Open-Source Benchmarks
+
+### CardDemo (AWS)
+
+| Metric | Value |
+| ------ | ----- |
+| Graph nodes | 12,323 |
+| Graph edges | 8,893 |
+| Total time | 7.4s |
+
+### ACAS
+
+| Metric | Value |
+| ------ | ----- |
+| Graph nodes | 14,016 |
+| Graph edges | 15,452 |
+| Total time | 9.3s |
+
+### Micro-Benchmark (Single-File Extraction)
+
+| Metric | Value |
+| ------ | ----- |
+| Per-iteration | 0.65ms |
+| Throughput | ~382K lines/sec |
+
+## Worker Pool Tuning
+
+### Sub-Batch Size
+
+The worker pool splits each worker's chunk into sub-batches to bound peak memory per `postMessage` serialization. COBOL repos use a smaller sub-batch size than the default:
+
+| Parameter             | Default     | COBOL Mode          |
+| --------------------- | ----------- | ------------------- |
+| Sub-batch size        | 1,500 files | 200 files           |
+| Per sub-batch timeout | 120s        | 120s (configurable) |
+
+**Why 200?** COBOL regex extraction + preprocessing takes ~1ms per file on average, but with COPY expansion and deep indexing the effective time is ~150ms per file. At sub-batch size 1500, that would be ~225s per sub-batch, exceeding the 120s timeout.
+
+COBOL mode is activated automatically when `GITNEXUS_COBOL_DIRS` is set:
+
+```typescript
+// From pipeline.ts
+const cobolSubBatch = process.env.GITNEXUS_COBOL_DIRS ? 200 : undefined;
+workerPool = createWorkerPool(workerUrl, undefined, cobolSubBatch);
+```
+
+### Worker Count
+
+Workers default to `min(8, cpus - 1)`. For COBOL repos, this is usually sufficient since regex extraction is CPU-bound but fast. The bottleneck is typically KuzuDB write, not extraction.
+
+### Timeout Configuration
+
+| Environment Variable                 | Default         | Purpose                                             |
+| ------------------------------------ | --------------- | --------------------------------------------------- |
+| `GITNEXUS_WORKER_TIMEOUT_MS`         | 120,000 (2 min) | Per sub-batch processing timeout                    |
+| `GITNEXUS_WORKER_STARTUP_TIMEOUT_MS` | 60,000 (1 min)  | Worker initialization timeout (tree-sitter loading) |
+
+For COBOL-only repos, worker startup is faster because tree-sitter native modules are loaded lazily (skipped entirely if only COBOL files are present).
+
+## Data Item Cap
+
+### Configuration
+
+```typescript
+const MAX_DATA_ITEMS_PER_FILE = 500;
+```
+
+This constant appears in both `parse-worker.ts` (worker path) and `parsing-processor.ts` (sequential fallback).
+
+### Rationale
+
+Some COBOL programs, especially after COPY expansion, can have 10,000+ data items. At that scale:
+
+- The in-memory relationship Map (for CONTAINS, REDEFINES, etc.) approaches the V8 16.7M entry limit across thousands of files
+- KuzuDB write time increases linearly with edge count
+- Most deep-nested items (level 20+) are rarely queried individually
+
+### Impact
+
+The cap truncates data items beyond the 500th in source order. Since 01-level Records appear first in COBOL source, the cap preserves:
+
+- All 01-level record definitions
+- The most important 02-49 level items (those closest to the record root)
+- 88-level conditions associated with early items
+
+To increase the cap for specific needs, modify the `MAX_DATA_ITEMS_PER_FILE` constant in both files.
+
+## Memory Management
+
+### COPY Expansion Breadth Guard
+
+A per-file `MAX_TOTAL_EXPANSIONS = 500` limit prevents exponential blowup from diamond-shaped COPY graphs (e.g., N copybooks each containing N COPY statements). Once the limit is reached, further COPY statements in that file are left unexpanded. See [copy-expansion.md](copy-expansion.md) for details.
+
+### COPY Expansion Memory
+
+All copybook content is loaded upfront into a Map before chunk processing begins. For PROJECT-NAME:
+
+- 2,976 copybooks, typically under 100MB total
+- The Map is shared (read-only) across chunk iterations
+- Per-chunk, the copybook map is merged with chunk file content (in case a chunk contains copybooks not in the pre-loaded set)
+- After all chunks are processed, the copybook map is freed (`cobolCopybookContents = undefined`)
+
+### Chunk Budget
+
+Source files are grouped into chunks of max 20MB (`CHUNK_BYTE_BUDGET`). Each chunk's lifecycle:
+
+1. Read file content into memory
+2. Expand COPY statements (mutates content in-place)
+3. Dispatch to workers for extraction
+4. Workers return serialized results
+5. Merge results into graph
+6. Chunk content goes out of scope (GC reclaims)
+
+This ensures only ~20MB of source + ~200-400MB of working memory (ASTs, extracted records, serialization) is active at any time.
+
+### Shared Warning Deduplication
+
+The `warnedCircular` set (used by the COPY expansion engine) is shared across all files in a chunk. This prevents the same circular copybook warning (e.g., `ANAZI includes itself`) from being logged thousands of times.
+
+## Known Limitations
+
+| Limitation                               | Impact                                                                                                          | Workaround                                                 |
+| ---------------------------------------- | --------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------- |
+| tree-sitter-cobol hangs on ~5% of files  | Cannot use tree-sitter for COBOL                                                                                | Regex-only extraction (current approach)                   |
+| Data item cap (500/file)                 | May miss deeply nested items in large programs                                                                  | Increase `MAX_DATA_ITEMS_PER_FILE` in source               |
+| Circular copybooks (ANAZI, ANDIP, QDIPE) | Self-referential includes cannot be expanded                                                                    | Detected and skipped with warning                          |
+| wfproc/ files may not be pure COBOL      | Workflow files may produce extraction noise                                                                     | Exclude `wfproc` from `GITNEXUS_COBOL_DIRS` if problematic |
+| No MOVE DATA_FLOW edges yet              | Data flow between variables not in graph                                                                        | Reserved for future release                                |
+| Continuation line handling               | Some complex multi-line continuations (especially in string literals spanning 3+ lines) may not merge correctly | Known edge case; affects <0.1% of lines                    |
+| Single-line EXEC blocks                  | `EXEC SQL SELECT ... END-EXEC` on one line is handled, but pathological nesting is not                          | Extremely rare in practice                                 |
+| Extension case sensitivity               | `.GNM` and `.gnm` are matched differently                                                                       | Use the exact case from the codebase                       |
+
+## Troubleshooting
+
+### "COPY expansion failed"
+
+```
+[pipeline] COPY expansion failed for s/BGTABFL: Cannot read properties of null
+```
+
+**Cause:** A copybook referenced by a COPY statement cannot be found.
+
+**Fix:**
+
+1. Verify `GITNEXUS_COBOL_DIRS` includes the directory containing copybooks (typically `c`)
+2. Check that copybook filenames match the COPY target (case-insensitive, after stripping extensions)
+3. Ensure copybook files are not in `.gitignore`
+
+### Worker sub-batch timeout
+
+```
+Worker 3 sub-batch timed out after 120s (chunk: 200 items)
+```
+
+**Cause:** A sub-batch took longer than the timeout. Typically happens when one file is extremely large (50,000+ lines after COPY expansion).
+
+**Fix:** Increase the timeout:
+
+```bash
+GITNEXUS_WORKER_TIMEOUT_MS=300000 gitnexus analyze
+```
+
+### Memory errors (heap out of memory)
+
+```
+FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory
+```
+
+**Fix:** Increase Node.js heap size:
+
+```bash
+node --max-old-space-size=16384 /path/to/gitnexus/dist/cli/index.js analyze
+```
+
+For very large repos (>500MB source), consider `--max-old-space-size=32768`.
+
+### Concurrent analyze corruption
+
+**Rule:** Only ONE `gitnexus analyze` process should run at a time per repository. Concurrent writes to KuzuDB corrupt the database.
+
+If corruption occurs:
+
+```bash
+# Remove the KuzuDB directory and re-index
+rm -rf .gitnexus/kuzu
+gitnexus analyze --force
+```
+
+### Slow KuzuDB write phase
+
+The KuzuDB write phase (132s for PROJECT-NAME) is the bottleneck for large COBOL repos. This is proportional to the number of nodes and edges being written. Reducing `MAX_DATA_ITEMS_PER_FILE` or excluding non-essential directories from `GITNEXUS_COBOL_DIRS` can help.
+
+### Verbose output
+
+Enable verbose logging to see per-phase timing and statistics:
+
+```bash
+GITNEXUS_VERBOSE=1 gitnexus analyze
+```
+
+This outputs:
+
+- Scan statistics (paths, parseable files, chunk count)
+- Worker pool configuration (worker count, sub-batch size)
+- COPY expansion statistics (copybooks loaded, files expanded)
+- Community and process detection results
+- Contract detection results
+
+## Source Files
+
+- `gitnexus/src/core/ingestion/workers/worker-pool.ts` -- `DEFAULT_SUB_BATCH_SIZE`, `SUB_BATCH_TIMEOUT_MS`, `WORKER_STARTUP_TIMEOUT_MS`
+- `gitnexus/src/core/ingestion/pipeline.ts` -- `CHUNK_BYTE_BUDGET`, COBOL sub-batch configuration, chunk lifecycle
+- `gitnexus/src/core/ingestion/workers/parse-worker.ts` -- `MAX_DATA_ITEMS_PER_FILE`, `processCobolRegexOnly()`
+- `gitnexus/src/core/ingestion/parsing-processor.ts` -- Sequential fallback `MAX_DATA_ITEMS_PER_FILE`

docs/code-indexing/cobol/regex-extraction.md

@@ -0,0 +1,206 @@
+# COBOL Regex Extraction
+
+The `extractCobolSymbolsWithRegex()` function in `cobol-preprocessor.ts` performs single-pass, state-machine-driven extraction of all COBOL symbols. This document describes the state machine, line processing flow, and every regex pattern used.
+
+## State Machine: Division Tracking
+
+The extractor tracks which COBOL division is currently being processed. Division transitions are detected by the `RE_DIVISION` pattern.
+
+```mermaid
+stateDiagram-v2
+    [*] --> null : Start of file
+    null --> identification : IDENTIFICATION DIVISION
+    identification --> environment : ENVIRONMENT DIVISION
+    environment --> data : DATA DIVISION
+    data --> procedure : PROCEDURE DIVISION
+
+    note right of identification
+        Extracts: PROGRAM-ID, AUTHOR, DATE-WRITTEN
+    end note
+    note right of environment
+        Extracts: SELECT ... ASSIGN ... (file declarations)
+    end note
+    note right of data
+        Extracts: FD entries, data items (01-77, 88), COPY
+    end note
+    note right of procedure
+        Extracts: paragraphs, sections, PERFORM, CALL,
+        ENTRY, MOVE, EXEC SQL/CICS
+    end note
+```
+
+## State Machine: Data Section Tracking
+
+Within the DATA DIVISION, a secondary state machine tracks the current section to tag data items with their origin.
+
+```mermaid
+stateDiagram-v2
+    [*] --> unknown : DATA DIVISION entered
+    unknown --> working_storage : WORKING-STORAGE SECTION
+    unknown --> linkage : LINKAGE SECTION
+    unknown --> file : FILE SECTION
+    unknown --> local_storage : LOCAL-STORAGE SECTION
+    working_storage --> linkage : LINKAGE SECTION
+    working_storage --> file : FILE SECTION
+    linkage --> working_storage : WORKING-STORAGE SECTION
+    file --> working_storage : WORKING-STORAGE SECTION
+    file --> linkage : LINKAGE SECTION
+    local_storage --> working_storage : WORKING-STORAGE SECTION
+```
+
+Within the ENVIRONMENT DIVISION, the `currentEnvSection` tracks whether we are in `INPUT-OUTPUT` or `CONFIGURATION` section. SELECT statement accumulation only occurs in `INPUT-OUTPUT`.
+
+## Line Processing Flow
+
+Each raw source line goes through this pipeline:
+
+```
+Raw line
+  |
+  v
+Length < 7? ---------> Skip (flush pending if any)
+  |
+  v
+Indicator col 7
+  |
+  +-- '*' or '/' -----> Comment: skip entirely
+  |
+  +-- '-' ------------> Continuation: append to pending line
+  |
+  +-- other ----------> Normal: flush pending, strip inline comments (|),
+                        buffer as new pending logical line
+```
+
+After all lines are processed, the final pending line is flushed, along with any accumulated SELECT statement, SORT/MERGE accumulator, and any open EXEC block (truncated file without `END-EXEC`).
+
+### Inline Comment Stripping
+
+Enterprise COBOL (particularly Italian dialect) uses the pipe character `|` as an inline comment marker. The `stripInlineComment()` helper is **quote-aware**: it tracks whether the scan position is inside a single- or double-quoted string and only treats `|` as a comment marker when outside quotes. Pipe characters inside string literals are preserved.
+
+Free-format `*>` inline comment stripping uses the same quote-aware approach: the scanner walks character by character, toggling quote state, and only recognizes `*>` as a comment marker when not inside a quoted string.
+
+### Patch Marker Handling
+
+The `preprocessCobolSource()` function (run before extraction in the worker) replaces non-standard content in columns 1-6. Standard COBOL expects spaces or digit sequence numbers in this area. If any letter or `#` character is found, the entire sequence area is replaced with 6 spaces:
+
+```
+Before: mzADD MOVE WK-AMT TO WK-TOTAL
+After:        MOVE WK-AMT TO WK-TOTAL
+```
+
+This preserves exact line count for position mapping.
+
+## Regex Pattern Reference
+
+All patterns are compiled once as module-level constants and reused across calls.
+
+### Division and Section Detection
+
+| Constant | Pattern | Purpose | Example Match |
+|----------|---------|---------|---------------|
+| `RE_DIVISION` | `\b(IDENTIFICATION\|ENVIRONMENT\|DATA\|PROCEDURE)\s+DIVISION\b` | Division boundary | `PROCEDURE DIVISION` |
+| `RE_SECTION` | `\b(WORKING-STORAGE\|LINKAGE\|FILE\|LOCAL-STORAGE\|INPUT-OUTPUT\|CONFIGURATION)\s+SECTION\b` | Section boundary | `WORKING-STORAGE SECTION` |
+
+### IDENTIFICATION DIVISION
+
+| Constant | Pattern | Purpose | Example Match |
+|----------|---------|---------|---------------|
+| `RE_PROGRAM_ID` | `\bPROGRAM-ID\.\s*([A-Z][A-Z0-9-]*)` | Program name | `PROGRAM-ID. BGTABFL` |
+| `RE_AUTHOR` | `^\s+AUTHOR\.\s*(.+)` | Author metadata | `AUTHOR. D. Smith` |
+| `RE_DATE_WRITTEN` | `^\s+DATE-WRITTEN\.\s*(.+)` | Date metadata | `DATE-WRITTEN. 2024-01-15` |
+
+### ENVIRONMENT DIVISION
+
+| Constant | Pattern | Purpose | Example Match |
+|----------|---------|---------|---------------|
+| `RE_SELECT_START` | `\bSELECT\s+(?:OPTIONAL\s+)?([A-Z][A-Z0-9-]+)` | File SELECT start (with optional `SELECT OPTIONAL` support) | `SELECT MASTER-FILE`, `SELECT OPTIONAL TRANS-FILE` |
+
+SELECT statements are accumulated across multiple lines until a period terminator is found, then parsed for ASSIGN, ORGANIZATION, ACCESS, RECORD KEY, and FILE STATUS clauses.
+
+### DATA DIVISION
+
+| Constant | Pattern | Purpose | Example Match |
+|----------|---------|---------|---------------|
+| `RE_FD` | `^\s+FD\s+([A-Z][A-Z0-9-]+)` | File description | `FD MASTER-FILE` |
+| `RE_DATA_ITEM` | `^\s+(\d{1,2})\s+([A-Z][A-Z0-9-]+)\s*(.*)` | Data item (01-77) | `05 WK-NAME PIC X(30)` |
+| `RE_ANONYMOUS_REDEFINES` | `^\s+(\d{1,2})\s+REDEFINES\s+([A-Z][A-Z0-9-]+)` | Anonymous REDEFINES | `01 REDEFINES WK-REC` |
+| `RE_88_LEVEL` | `^\s+88\s+([A-Z][A-Z0-9-]+)\s+VALUES?\s+(?:ARE\s+)?(.+)` | Condition name | `88 WK-ACTIVE VALUE "Y"` |
+
+The trailing clauses of `RE_DATA_ITEM` are parsed by `parseDataItemClauses()` for PIC, USAGE, OCCURS, and REDEFINES.
+
+### PROCEDURE DIVISION
+
+| Constant | Pattern | Purpose | Example Match |
+|----------|---------|---------|---------------|
+| `RE_PROC_SECTION` | `^       ([A-Z][A-Z0-9-]+)\s+SECTION\.\s*$` | Procedure section header | `       MAIN-LOGIC SECTION.` |
+| `RE_PROC_PARAGRAPH` | `^       ([A-Z][A-Z0-9-]+)\.\s*$` | Paragraph header | `       PROCESS-RECORD.` |
+| `RE_PERFORM` | `\bPERFORM\s+([A-Z][A-Z0-9-]+)(?:\s+THRU\s+([A-Z][A-Z0-9-]+))?` | PERFORM call | `PERFORM CALC-TAX THRU CALC-TAX-EXIT` |
+| `RE_PROC_USING` | `\bPROCEDURE\s+DIVISION\s+USING\s+([\s\S]*?)(?:\.\|$)` | USING parameters | `PROCEDURE DIVISION USING WK-PARAM` |
+| `RE_ENTRY` | `\bENTRY\s+"([^"]+)"(?:\s+USING\s+([\s\S]*?))?(?:\.\|$)` | ENTRY point | `ENTRY "SUBPROG" USING WK-DATA` |
+| `RE_MOVE` | `\bMOVE\s+((?:CORRESPONDING\|CORR)\s+)?([A-Z][A-Z0-9-]+)\s+TO\s+(.+)` | MOVE statement (supports CORR abbreviation and multi-target) | `MOVE WK-NAME TO OUT-NAME`, `MOVE CORR WK-IN TO WK-OUT` |
+
+The USING parameter list (`RE_PROC_USING`) is split on `\bRETURNING\b` before tokenization -- any RETURNING clause and everything after it is excluded from the parameter list (`.split(/\bRETURNING\b/i)[0]`).
+
+Note: `RE_PROC_SECTION` and `RE_PROC_PARAGRAPH` require exactly 7 spaces of leading indentation (COBOL area A starting at column 8). This is the standard COBOL paragraph indentation.
+
+### All-Division Patterns
+
+These patterns are checked regardless of current division:
+
+| Constant | Pattern | Purpose | Example Match |
+|----------|---------|---------|---------------|
+| `RE_CALL` | `\bCALL\s+"([^"]+)"` | External program call | `CALL "BGTABUP"` |
+| `RE_COPY_UNQUOTED` | `\bCOPY\s+([A-Z][A-Z0-9-]+)(?:\s\|\.)` | COPY (unquoted) | `COPY CPSESP.` |
+| `RE_COPY_QUOTED` | `\bCOPY\s+"([^"]+)"(?:\s\|\.)` | COPY (quoted) | `COPY "WORKGRID.CPY".` |
+
+### SORT/MERGE Support
+
+| Constant | Purpose |
+|----------|---------|
+| `SORT_CLAUSE_NOISE` | Set of SORT/MERGE clause keywords filtered from USING/GIVING file lists: `ON`, `ASCENDING`, `DESCENDING`, `KEY`, `WITH`, `DUPLICATES`, `IN`, `ORDER`, `COLLATING`, `SEQUENCE`, `IS`, `THROUGH`, `THRU`, `INPUT`, `OUTPUT`, `PROCEDURE` |
+
+SORT and MERGE statements are accumulated across multiple lines (like SELECT) until a period terminator is found, then parsed for USING/GIVING file lists and INPUT/OUTPUT PROCEDURE targets. The `flushSort()` helper encapsulates the flush-and-parse logic, mirroring the existing `flushSelect()` pattern. Both helpers are called at EOF to handle truncated files.
+
+### GO TO Multi-Target
+
+`RE_GOTO` captures all paragraph names in a `GO TO` statement, including the multi-target form `GO TO p1 p2 p3 DEPENDING ON x`. The captured group contains all target names (space-separated), which are split into individual targets. Each target produces a separate `gotos` entry.
+
+### PROGRAM-ID Detection
+
+PROGRAM-ID is detected regardless of the current division state. This handles sibling programs that appear after `END PROGRAM` and omit the `IDENTIFICATION DIVISION` header -- the extractor will still capture the PROGRAM-ID and push a new program boundary.
+
+### EXEC Block Patterns
+
+| Constant | Pattern | Purpose | Example Match |
+|----------|---------|---------|---------------|
+| `RE_EXEC_SQL_START` | `\bEXEC\s+SQL\b` | Start of EXEC SQL block | `EXEC SQL` |
+| `RE_EXEC_CICS_START` | `\bEXEC\s+CICS\b` | Start of EXEC CICS block | `EXEC CICS` |
+| `RE_END_EXEC` | `\bEND-EXEC\b` | End of EXEC block | `END-EXEC` |
+
+EXEC blocks accumulate all lines between `EXEC SQL/CICS` and `END-EXEC`, then delegate to `parseExecSqlBlock()` or `parseExecCicsBlock()` for detailed extraction.
+
+## Excluded Paragraph Names
+
+The following names are excluded from paragraph detection to avoid false positives from division/section headers:
+
+```
+DECLARATIVES, END, PROCEDURE, IDENTIFICATION,
+ENVIRONMENT, DATA, WORKING-STORAGE, LINKAGE,
+FILE, LOCAL-STORAGE, COMMUNICATION, REPORT,
+SCREEN, INPUT-OUTPUT, CONFIGURATION
+```
+
+Additionally, paragraph candidates containing `DIVISION` or `SECTION` as substrings are excluded.
+
+## MOVE Skip List (Figurative Constants)
+
+MOVE statements where the source is a figurative constant are skipped:
+
+```
+SPACES, ZEROS, ZEROES, LOW-VALUES, LOW-VALUE,
+HIGH-VALUES, HIGH-VALUE, QUOTES, QUOTE, ALL
+```
+
+## Source Files
+
+- `gitnexus/src/core/ingestion/cobol-preprocessor.ts` -- `preprocessCobolSource()`, `extractCobolSymbolsWithRegex()`, all regex constants

docs/plans/2026-03-26-feat-cobol-full-language-coverage-plan.md

@@ -0,0 +1,326 @@
+---
+title: "feat: Complete COBOL language feature coverage for maximum knowledge graph value"
+type: feat
+status: active
+date: 2026-03-26
+origin: Feature audit from v3-integration-architect agent (session 8642401e)
+---
+
+## Enhancement Summary
+
+**Deepened on:** 2026-03-26
+**Research agents used:** COBOL expert (Phase 1+2), graph value analyst, codebase explorer
+**Sections enhanced:** Phase 1 (5 features), Phase 2 (4 features), graph value ranking
+
+### Key Improvements from Research
+1. **CALL USING** is the #1 highest-value edge type (9.2/10) — fixes ~40% of missing caller references
+2. **EXEC DLI** requires dual-interface support (EXEC DLI + CBLTDLI CALL) for full IMS coverage
+3. **DECLARATIVES** is lowest-risk Phase 2 item — existing section/paragraph detection already captures structure
+4. **SET TO TRUE** accounts for 80-90% of all SET statements — prioritize this form
+5. **INSPECT** needs multi-line accumulator (like SORT) — can span 5+ continuation lines
+6. **Graph value ranking**: cobol-call-using (9.2) > cobol-error-handler (9.0) > dli-gu (8.2) > cobol-string (6.2)
+
+### New Edge Cases Discovered
+- CALL USING supports mixed modes: `USING BY REFERENCE WS-A BY CONTENT WS-B BY VALUE WS-C`
+- CALL USING `ADDRESS OF` and `OMITTED` must be filtered from parameter lists
+- EXEC DLI can have multiple SEGMENT levels in hierarchical retrieval (use matchAll)
+- DECLARATIVES can have multiple USE sections (one per file + catch-all for INPUT/OUTPUT/I-O/EXTEND)
+- INSPECT TALLYING can have multiple counters in a single statement
+- STRING/UNSTRING can span multiple lines (need accumulator pattern)
+
+---
+
+# Complete COBOL Language Feature Coverage
+
+## Overview
+
+Implement the remaining 25 unhandled COBOL language features and fix 10 partial features to achieve ~95% coverage (up from 71.9%). The goal is to build the richest possible knowledge graph from COBOL codebases, enabling a future `modernize` MCP command (out of scope for this plan) that would use the graph to assist with COBOL-to-modern-language migration.
+
+## Problem Statement
+
+The COBOL processor currently handles 54 of 89 applicable language features (71.9%). The 25 unhandled features represent real data loss in the knowledge graph:
+- **Cross-program data flow** is invisible (CALL ... USING parameters not extracted)
+- **IMS/DB programs** produce empty graphs (EXEC DLI not recognized)
+- **String transformation logic** is invisible (STRING/UNSTRING/INSPECT not tracked)
+- **SQL copybook dependencies** are missing (EXEC SQL INCLUDE not mapped)
+- **Error handling flows** are lost (DECLARATIVES/USE AFTER not captured)
+
+## Proposed Solution
+
+Implement features in 4 phases, ordered by graph value density (edges created per LOC of implementation). Each phase is independently shippable and testable.
+
+## Technical Approach
+
+### Phase 1: High-Value Data Flow Edges (~150 LOC, ~8 new edge types)
+
+The highest-ROI features: they create new ACCESSES and IMPORTS edges that directly improve impact analysis.
+
+**Critical research finding**: Multi-line statement accumulation is the dominant challenge. CALL USING, STRING/UNSTRING, and multi-line data item clauses all span multiple lines in production COBOL. The free-format path processes each line independently — these features need statement accumulators (like SORT/SELECT) or the free-format path needs multi-line awareness. Estimated LOC increased from 110 to 150 to account for accumulator infrastructure.
+
+#### 1.1 EXEC SQL INCLUDE -> IMPORTS edges
+- **File:** `cobol-preprocessor.ts` (parseExecSqlBlock)
+- **What:** Detect `INCLUDE` as the operation, extract member name, emit as a `copies[]` entry
+- **Graph:** IMPORTS edge from File to included copybook/SQLCA with reason `sql-include`
+- **Tests:** Unit test for `EXEC SQL INCLUDE SQLCA END-EXEC` and `EXEC SQL INCLUDE CUSTCOPY END-EXEC`
+
+**Research insights (EXEC SQL INCLUDE):**
+- DB2 member names can contain underscores: `EXEC SQL INCLUDE CUST_TBL_DCL END-EXEC` — regex must use `[A-Z][A-Z0-9_-]+`
+- Quoted literal form: `EXEC SQL INCLUDE 'DBRMLIB.MEMBER' END-EXEC` (z/OS PDS qualified name)
+- SQLCA/SQLDA are DB2 builtins — won't resolve to repo files. Emit unresolved IMPORTS edge (still valuable)
+- No REPLACING support on EXEC SQL INCLUDE (unlike COPY)
+- Add `INCLUDE` to `OP_MAP` in `parseExecSqlBlock`; extract member via `RE_SQL_INCLUDE = /^INCLUDE\s+(?:'([^']+)'|"([^"]+)"|([A-Z][A-Z0-9_-]+))/i`
+
+#### 1.2 CALL ... USING parameter extraction -> ACCESSES edges (Graph value: 9.2/10)
+- **File:** `cobol-preprocessor.ts` (processLogicalLine CALL section)
+- **What:** After capturing CALL target, scan for USING clause. Extract parameter names (reuse USING_KEYWORDS filter). Store as `calls[].parameters: string[]`
+- **Interface:** Add `parameters?: string[]` to calls array type in CobolRegexResults
+- **File:** `cobol-processor.ts` (CALL edge block)
+- **Graph:** For each USING parameter, create ACCESSES edge from caller to data item Property node with reason `cobol-call-using`
+- **Tests:** `CALL 'AUDITLOG' USING CUST-ID WS-AMOUNT` -> 2 ACCESSES edges
+
+**Research insights (CALL USING forms):**
+- Mixed modes: `CALL 'PGM' USING BY REFERENCE WS-A BY CONTENT WS-B BY VALUE WS-C`
+- Pointer passing: `CALL 'PGM' USING ADDRESS OF WS-A`
+- Placeholder: `CALL 'PGM' USING OMITTED WS-B`
+- Filter keywords: add `ADDRESS`, `OMITTED`, `LENGTH` to USING_KEYWORDS (already has BY/VALUE/REFERENCE/CONTENT)
+- **Impact tool enhancement:** CALL-USING edges enable BFS traversal through parameter data flow — single most impactful edge type for COBOL impact analysis
+
+#### 1.3 STRING/UNSTRING data flow -> ACCESSES edges
+- **File:** `cobol-preprocessor.ts` (new section in extractProcedure)
+- **What:** Accumulate multi-line STRING/UNSTRING until period or END-STRING/END-UNSTRING. Extract sources and INTO targets.
+- **Interface:** Add `strings: Array<{ sources: string[]; target: string; type: 'string' | 'unstring'; line: number; caller: string | null }>` to CobolRegexResults
+- **Graph:** read-ACCESSES on sources, write-ACCESSES on INTO target with reason `cobol-string-read` / `cobol-string-write`
+- **Tests:** 2 unit tests + integration test assertions
+
+**Research insights (STRING/UNSTRING):**
+- **Needs statement accumulator** — STRING/UNSTRING always span multiple lines in production
+- Terminate accumulation at: period, END-STRING/END-UNSTRING, or start of next COBOL verb
+- STRING sources: identifiers before each `DELIMITED BY`. Filter: STRING, DELIMITED, BY, SIZE, ALL, INTO, WITH, POINTER, ON, OVERFLOW, NOT, END-STRING
+- UNSTRING: source is first identifier after UNSTRING; INTO targets are identifiers after INTO. Filter: DELIMITER, IN, COUNT, TALLYING, OR
+- WITH POINTER field is both read AND written (starting position updated)
+- TALLYING IN / COUNT IN fields are write targets
+- Literal sources (`'text'`) must be filtered — quote-aware tokenization needed
+- **Edge case**: STRING terminated by next verb, not period — existing fixture has `STRING ... DISPLAY` without period between them
+
+#### 1.4 OCCURS DEPENDING ON -> ACCESSES edge
+- **File:** `cobol-preprocessor.ts` (parseDataItemClauses)
+- **What:** Extend OCCURS regex to capture DEPENDING ON field, KEY fields, and INDEXED BY names
+- **Interface:** Add `dependingOn?: string`, `occursMax?: number`, `occursKeys?: Array<{direction: string; fields: string[]}>`, `indexedBy?: string[]` to data items
+- **Graph:** ACCESSES edge from table item to controlling field with reason `cobol-depends-on`
+- **Tests:** `05 WS-TABLE OCCURS 100 DEPENDING ON WS-COUNT` -> edge
+
+**Research insights (OCCURS):**
+- IBM allows `OCCURS 0 TO n DEPENDING ON` (zero minimum) and `OCCURS UNBOUNDED DEPENDING ON` (V6.4)
+- Subscripted controlling fields: `DEPENDING ON WS-COUNT(WS-IDX)` — strip subscripts before storing
+- **Pre-existing gap**: Multi-line data item clauses without continuation indicator are NOT captured. `05 WS-TABLE\n    OCCURS 100\n    DEPENDING ON WS-COUNT.` — the current RE_DATA_ITEM only gets the first line, `rest` is empty. Fixing properly requires a data item accumulator (like SELECT). **Defer full fix to Phase 3; implement same-line capture now.**
+- KEY IS fields: `ASCENDING KEY IS WS-KEY-1 WS-KEY-2` — capture for SEARCH ALL resolution
+- INDEXED BY: `INDEXED BY IDX-1 IDX-2` — capture for SET/SEARCH context
+
+#### 1.5 VALUE clause for standard data items
+- **File:** `cobol-preprocessor.ts` (parseDataItemClauses)
+- **What:** Extract VALUE using a pragmatic function that handles quoted strings, numerics, figurative constants, hex/national literals
+- **Interface:** Already exists as `values?: string[]` on data items (currently only populated for 88-level)
+- **Graph:** Stored in Property node description (no new edges)
+- **Tests:** `01 WS-STATUS PIC X VALUE 'A'` -> values: ['A']
+
+**Research insights (VALUE forms):**
+- Hex literals: `VALUE X'F1F2F3F4'`, National: `VALUE N'text'`, DBCS: `VALUE G'text'`
+- Figurative constants: SPACES, ZEROS, ZEROES, LOW-VALUES, HIGH-VALUES, QUOTES, NULL, NULLS
+- ALL literal: `VALUE ALL '*'`
+- Numeric with sign/decimal: `VALUE -123.45`, `VALUE +1`
+- `VALUE IS` optional — both `VALUE 'A'` and `VALUE IS 'A'` valid
+- **Decimal vs period ambiguity**: `VALUE 100.` — is `.` decimal or terminator? `parseDataItemClauses` already strips trailing period, so this is handled
+- IBM V6.4: floating-point `VALUE 1.0E5` — extend numeric regex if needed
+- Implementation: use a pragmatic `extractValue(rest)` function, not a single complex regex
+
+### Phase 2: EXEC DLI + DECLARATIVES (~90 LOC, ~4 new edge types)
+
+IMS/DB support and error handling flows.
+
+#### 2.1 EXEC DLI (IMS/DB) -> ACCESSES edges (Graph value: 8.2/10)
+- **File:** `cobol-preprocessor.ts` (processLogicalLine — add RE_EXEC_DLI_START check alongside SQL/CICS)
+- **What:** Accumulate EXEC DLI blocks like EXEC SQL. Parse DLI verbs (GU, GN, GNP, GHU, GHN, GHNP, ISRT, DLET, REPL, CHKP, SCHD, TERM). Extract segment name, PCB number, INTO/FROM areas, WHERE fields, PSB name.
+- **Interface:** Add `execDliBlocks: Array<{ line: number; verb: string; pcbNumber?: number; segmentName?: string; intoField?: string; fromField?: string; whereField?: string; psbName?: string }>` to CobolRegexResults
+- **Graph:** CodeElement node + ACCESSES edge to `<ims>:<segmentName>` Record node with reason `dli-{verb}`; ACCESSES edges to INTO/FROM data areas; PSB ACCESSES for SCHD
+- **Tests:** `EXEC DLI GU USING PCB(1) SEGMENT(CUSTOMER) INTO(WS-CUST) END-EXEC`
+
+**Research insights (dual IMS interface):**
+- **EXEC DLI**: Embedded command interface for CICS-DL/I programs only
+- **CBLTDLI CALL**: Batch interface via `CALL 'CBLTDLI' USING function-code PCB io-area SSA1..SSA15`
+- CBLTDLI is already captured as a CALL to 'CBLTDLI' — enrich with USING parameter semantics later
+- Multiple SEGMENT levels in hierarchical retrieval — use `matchAll` on segment regex
+- DLI verbs: GU (most common), GN, GNP, GHU, GHN, GHNP, ISRT, REPL, DLET, CHKP, SCHD, TERM, ROLL, ROLB
+- **Edge case**: DLET/REPL have no SEGMENT clause (operate on current position)
+- **Recommended order**: Implement AFTER DECLARATIVES and SET (lower risk, higher frequency)
+
+#### 2.2 DECLARATIVES / USE AFTER STANDARD EXCEPTION (Graph value: 9.0/10)
+- **File:** `cobol-preprocessor.ts` (processLogicalLine — detect DECLARATIVES keyword, track USE AFTER blocks)
+- **What:** When `DECLARATIVES.` is encountered, switch to declaratives mode. Extract USE statements binding sections to files/modes.
+- **Interface:** Add `declaratives: Array<{ sectionName: string; useType: 'error' | 'debug' | 'label' | 'reporting'; target: string; line: number }>` to CobolRegexResults
+- **Graph:** ACCESSES edge from declarative Namespace to file Record with reason `cobol-declarative-error-handler`
+- **Tests:** Unit test with DECLARATIVES section, integration test for error flow
+
+**Research insights (DECLARATIVES syntax):**
+- `USE AFTER STANDARD {EXCEPTION|ERROR} ON {file-name|INPUT|OUTPUT|I-O|EXTEND}`
+- EXCEPTION and ERROR are synonymous; STANDARD is optional in IBM dialects
+- Multiple USE sections allowed (one per file + catch-all for I/O modes)
+- `END DECLARATIVES.` must NOT reset PROCEDURE DIVISION state
+- `DECLARATIVES` is already in EXCLUDED_PARA_NAMES — no false paragraph risk
+- Existing section/paragraph detection already captures structural elements — just need USE binding
+- **Lowest risk Phase 2 item** — implement first
+
+#### 2.3 SET statement -> ACCESSES edges
+- **File:** `cobol-preprocessor.ts` (extractProcedure — new RE_SET regex)
+- **Interface:** Add `sets: Array<{ targets: string[]; form: 'to-true'|'to-value'|'up-by'|'down-by'|'address-of'|'to-null'|'to-entry'; value?: string; entryTarget?: string; entryIsLiteral?: boolean; line: number; caller: string | null }>` to CobolRegexResults
+- **Graph:** ACCESSES write edge with reason `cobol-set-condition` (TO TRUE), `cobol-set-index` (TO/UP/DOWN), `cobol-set-address` (ADDRESS OF). SET ENTRY with literal -> CALLS edge.
+- **Tests:** `SET WS-EOF TO TRUE`, `SET IDX-1 TO 5`, `SET IDX-1 UP BY 1`
+
+**Research insights (SET forms by frequency):**
+- `SET condition TO TRUE` — 80-90% of all SET usage. Multiple targets: `SET COND-A COND-B TO TRUE`
+- `SET index TO/UP BY/DOWN BY` — ~8%. Multiple indices: `SET IDX-1 IDX-2 UP BY 1`
+- `SET pointer TO ADDRESS OF data-item` / `SET ADDRESS OF data-item TO pointer` — ~2%
+- `SET proc-ptr TO ENTRY "PROGNAME"` — rare but creates CALLS edge (like dynamic CALL)
+- Filter OF/IN qualifiers: `SET COND-A OF WS-RECORD TO TRUE` (strip OF WS-RECORD)
+- **Prioritize**: SET TO TRUE alone covers 80-90% — implement this form first
+
+#### 2.4 INSPECT -> ACCESSES edges
+- **File:** `cobol-preprocessor.ts` (extractProcedure — new `inspectAccum` accumulator like SORT)
+- **What:** Accumulate multi-line INSPECT until period. Extract inspected field + tally counters.
+- **Interface:** Add `inspects: Array<{ inspectedField: string; counters: string[]; form: 'tallying'|'replacing'|'converting'|'tallying-replacing'; line: number; caller: string | null }>` to CobolRegexResults
+- **Graph:** ACCESSES read on inspected field always; write if REPLACING/CONVERTING. Write edges for tally counters. Reason: `cobol-inspect-read`/`cobol-inspect-write`/`cobol-inspect-tally`
+- **Tests:** `INSPECT WS-FIELD TALLYING WS-COUNT FOR ALL 'A'` -> read on WS-FIELD, write on WS-COUNT
+
+**Research insights (INSPECT forms by frequency):**
+- REPLACING (~60%): `INSPECT WS-STR REPLACING ALL 'A' BY 'B'`
+- TALLYING (~25%): `INSPECT WS-STR TALLYING WS-CNT FOR ALL 'A'` — multiple counters possible
+- CONVERTING (~10%): `INSPECT WS-STR CONVERTING 'abc' TO 'ABC'`
+- Combined (~5%): TALLYING + REPLACING in single statement
+- **Needs multi-line accumulator** — INSPECT frequently spans 3-5 lines in production
+- Extract tally counters with `([A-Z][A-Z0-9-]+)\s+FOR\b` matchAll pattern
+- Filter figurative constants (SPACES, ZEROS) using existing MOVE_SKIP set
+
+### Phase 3: Completeness Fixes (~60 LOC)
+
+Fix the 10 partial features and small gaps.
+
+#### 3.1 CALL ... RETURNING extraction
+- Extend RE_CALL processing to capture RETURNING target after the USING clause
+- Store as `calls[].returning?: string`
+- Graph: ACCESSES write edge with reason `cobol-call-returning`
+
+#### 3.2 SELECT OPTIONAL flag preservation
+- Store `isOptional: boolean` in FileDeclaration interface
+- Include in Record node description
+
+#### 3.3 ALTERNATE RECORD KEY extraction
+- Add regex in parseSelectStatement: `/\bALTERNATE\s+RECORD\s+KEY\s+(?:IS\s+)?([A-Z][A-Z0-9-]+)/i`
+- Store as `alternateKeys?: string[]`
+
+#### 3.4 COMMON attribute on nested programs
+- Extend RE_PROGRAM_ID: `/\bPROGRAM-ID\.\s*([A-Z][A-Z0-9-]+)(?:\s+IS\s+COMMON)?/i`
+- Store `isCommon: boolean` on Module node
+- Affects cross-program CALL resolution scope
+
+#### 3.5 IS EXTERNAL / IS GLOBAL as first-class properties
+- Change from usage string hack to proper boolean fields on data items
+- Add `isExternal?: boolean`, `isGlobal?: boolean` to data item interface
+
+#### 3.6 AUTHOR / DATE-WRITTEN mapped to Module node
+- Already extracted as programMetadata — map to Module node properties
+- `graph.addNode({ ..., properties: { ..., author, dateWritten } })`
+
+#### 3.7 REPLACE statement
+- Track REPLACE / REPLACE OFF state in preprocessor
+- Apply text substitutions during preprocessing (before regex extraction)
+- Complex: requires careful scoping rules
+
+### Phase 4: Niche Features (~30 LOC)
+
+Low-priority but nice for completeness.
+
+#### 4.1 INITIALIZE statement -> write ACCESSES
+- `/\bINITIALIZE\s+([A-Z][A-Z0-9-]+)/i`
+- ACCESSES write edge with reason `cobol-initialize`
+
+#### 4.2 Remaining IDENTIFICATION DIVISION paragraphs
+- DATE-COMPILED, INSTALLATION, SECURITY, REMARKS
+- Map to Module node description properties
+
+#### 4.3 EXEC SQL INCLUDE -> IMPORTS edge (expansion)
+- For EXEC SQL INCLUDE inside EXEC blocks that reference copybooks containing SQL
+- Create IMPORTS edge similar to COPY
+
+## Acceptance Criteria
+
+### Functional Requirements
+
+- [ ] Phase 1: All 5 features implemented with unit + integration tests
+- [ ] Phase 2: All 4 features implemented with unit + integration tests
+- [ ] Phase 3: All 7 partial features fixed
+- [ ] Phase 4: At least 2 of 3 niche features implemented
+- [ ] All existing 145 tests continue to pass
+- [ ] TypeScript compiles cleanly
+
+### Non-Functional Requirements
+
+- [ ] No performance regression: CardDemo benchmark stays under 8s
+- [ ] No file exceeds 1500 LOC (preprocessor currently 1326)
+- [ ] ACAS benchmark shows increased node/edge counts (more data extracted)
+- [ ] CardDemo benchmark shows increased edge counts (CALL USING, STRING, etc.)
+
+### Quality Gates
+
+- [ ] Each phase has its own commit
+- [ ] Integration test assertions updated with exact counts per phase
+- [ ] Benchmark run after each phase to track graph growth
+
+## Dependencies & Risks
+
+### Dependencies
+- None. All changes are additive to existing COBOL processor code.
+- No LanguageProvider changes needed.
+- No graph schema changes needed (all new constructs map to existing node labels + edge types).
+
+### Risks
+- **preprocessor.ts size**: Currently 1326 LOC. Phase 1+2 adds ~200 LOC -> 1526 LOC. May need to extract helpers into a separate `cobol-data-flow.ts` module if it exceeds 1500.
+- **REPLACE statement** (Phase 3.7) is the most complex feature — requires tracking text substitution state across logical lines. Consider deferring to a separate PR if it takes >100 LOC.
+- **EXEC DLI** (Phase 2.1) is only testable against IMS codebases. Need fixture data or synthetic test cases.
+
+## Graph Value Ranking by MCP Tool Impact
+
+Research agent analyzed all 5 MCP tools (query, context, impact, detect_changes, rename) against planned edge types:
+
+| Edge Type | QUERY | CONTEXT | IMPACT | DETECT | RENAME | **Overall** |
+|-----------|-------|---------|--------|--------|--------|-------------|
+| `cobol-call-using` | 4/5 | 5/5 | 5/5 | 4/5 | 4/5 | **9.2/10** |
+| `cobol-error-handler` | 5/5 | 4/5 | 5/5 | 5/5 | 2/5 | **9.0/10** |
+| `dli-*` (IMS verbs) | 4/5 | 4/5 | 5/5 | 4/5 | 2/5 | **8.2/10** |
+| `cobol-string-*` | 4/5 | 3/5 | 3/5 | 3/5 | 2/5 | **6.2/10** |
+
+**Key finding**: `cobol-call-using` alone would fix ~40% of missing caller references in COBOL graphs.
+
+## Future Considerations
+
+This plan provides the graph data foundation for a future `modernize` MCP command (out of scope) that would:
+- Use CALL USING edges to map data contracts between programs
+- Use STRING/UNSTRING edges to identify data transformation logic
+- Use EXEC SQL/DLI edges to map database access patterns
+- Use DECLARATIVES to understand error handling architecture
+- Use the complete knowledge graph to generate migration plans
+
+**MCP tool enhancements needed** (after this plan ships):
+- Add `cobol-call-using`, `cobol-error-handler`, `dli-*` to IMPACT tool's default `relationTypes` for COBOL repos
+- Add confidence floors for new edge types in `IMPACT_RELATION_CONFIDENCE`
+- Register new edge types in `VALID_RELATION_TYPES` set (`local-backend.ts:52`)
+
+## Sources & References
+
+### Internal References
+- Feature audit: session 8642401e (COBOL expert agent, 123 features audited)
+- Prior plans: `docs/plans/2026-03-25-feat-cobol-100-percent-feature-coverage-plan.md`
+- Architecture: `docs/code-indexing/cobol/` (7 documentation files)
+
+### External References
+- COBOL features reference: mainframestechhelp.com/tutorials/cobol/features.htm
+- COBOL-85 standard: ISO/IEC 1989:1985
+- IBM Enterprise COBOL reference

eslint.config.mjs

@@ -0,0 +1,83 @@
+import tsPlugin from '@typescript-eslint/eslint-plugin';
+import tsParser from '@typescript-eslint/parser';
+import unusedImports from 'eslint-plugin-unused-imports';
+import reactHooks from 'eslint-plugin-react-hooks';
+import prettierConfig from 'eslint-config-prettier';
+
+export default [
+  // Global ignores
+  {
+    ignores: [
+      '**/dist/**',
+      '**/node_modules/**',
+      '**/coverage/**',
+      'gitnexus/vendor/**',
+      'gitnexus-web/src/vendor/**',
+      'gitnexus/test/fixtures/**',
+      'gitnexus-web/playwright-report/**',
+      'gitnexus-web/test-results/**',
+      '**/*.d.ts',
+      '.claude/**',
+      '.history/**',
+    ],
+  },
+
+  // Base TypeScript config for all packages
+  {
+    files: ['**/*.{ts,tsx}'],
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        ecmaVersion: 2022,
+        sourceType: 'module',
+      },
+    },
+    plugins: {
+      '@typescript-eslint': tsPlugin,
+      'unused-imports': unusedImports,
+    },
+    rules: {
+      // Unused imports — auto-fixable
+      'unused-imports/no-unused-imports': 'error',
+      'unused-imports/no-unused-vars': [
+        'warn',
+        { vars: 'all', varsIgnorePattern: '^_', args: 'after-used', argsIgnorePattern: '^_' },
+      ],
+
+      // TypeScript quality
+      '@typescript-eslint/no-unused-vars': 'off', // handled by unused-imports plugin
+      'no-unused-vars': 'off', // handled by unused-imports plugin
+      '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/no-non-null-assertion': 'warn',
+
+      // General quality
+      'no-debugger': 'error',
+      'prefer-const': 'error',
+      'no-var': 'error',
+      eqeqeq: ['error', 'always', { null: 'ignore' }],
+    },
+  },
+
+  // CLI package — allow console.log (it's a CLI tool)
+  {
+    files: ['gitnexus/src/cli/**/*.ts', 'gitnexus/src/server/**/*.ts'],
+    rules: {
+      'no-console': 'off',
+    },
+  },
+
+  // React-specific rules for gitnexus-web
+  {
+    files: ['gitnexus-web/src/**/*.{ts,tsx}'],
+    plugins: {
+      'react-hooks': reactHooks,
+    },
+    rules: {
+      'react-hooks/rules-of-hooks': 'error',
+      'react-hooks/exhaustive-deps': 'warn',
+    },
+  },
+
+  // Disable formatting rules (prettier handles those)
+  prettierConfig,
+];

eval/README.md

@@ -50,6 +50,10 @@ All models are routed through **OpenRouter** by default, so a single `OPENROUTER
 docker pull swebench/sweb.eval.x86_64.django_1776_django-16527:latest
 ```
 
+### Debug logging
+
+Set `GITNEXUS_EVAL_DEBUG=1` to include full Python tracebacks in run summaries and logs. By default, errors are sanitized to avoid leaking host paths or stack traces.
+
 ## Quick Start
 
 ### Debug a single instance

eval/agents/gitnexus_agent.py

@@ -22,8 +22,10 @@ import time
 from enum import Enum
 from pathlib import Path
 
+from constants import AUGMENT_TIMEOUT_SECONDS
 from minisweagent import Environment, Model
 from minisweagent.agents.default import AgentConfig, DefaultAgent
+from tool_registry import BINARIES_BY_KEY, TOOL_METRIC_KEYS
 
 logger = logging.getLogger("gitnexus_agent")
 
@@ -40,7 +42,7 @@ class GitNexusMode(str, Enum):
 class GitNexusAgentConfig(AgentConfig):
     """Extended config for GitNexus evaluation agent."""
     gitnexus_mode: GitNexusMode = GitNexusMode.BASELINE
-    augment_timeout: float = 5.0
+    augment_timeout: float = AUGMENT_TIMEOUT_SECONDS
     augment_min_pattern_length: int = 3
     track_gitnexus_usage: bool = True
 
@@ -152,16 +154,10 @@ class GitNexusAgent(DefaultAgent):
         """Track which GitNexus tools the agent uses."""
         for action in message.get("extra", {}).get("actions", []):
             command = action.get("command", "")
-            if "gitnexus-query" in command:
-                self.gitnexus_metrics.tool_calls["query"] += 1
-            elif "gitnexus-context" in command:
-                self.gitnexus_metrics.tool_calls["context"] += 1
-            elif "gitnexus-impact" in command:
-                self.gitnexus_metrics.tool_calls["impact"] += 1
-            elif "gitnexus-cypher" in command:
-                self.gitnexus_metrics.tool_calls["cypher"] += 1
-            elif "gitnexus-overview" in command:
-                self.gitnexus_metrics.tool_calls["overview"] += 1
+            for key, binary in BINARIES_BY_KEY.items():
+                if binary in command and key in self.gitnexus_metrics.tool_calls:
+                    self.gitnexus_metrics.tool_calls[key] += 1
+                    break
 
     def serialize(self, *extra_dicts) -> dict:
         """Serialize with GitNexus-specific metrics."""
@@ -180,13 +176,7 @@ class GitNexusMetrics:
     """Tracks GitNexus-specific metrics during evaluation."""
 
     def __init__(self):
-        self.tool_calls: dict[str, int] = {
-            "query": 0,
-            "context": 0,
-            "impact": 0,
-            "cypher": 0,
-            "overview": 0,
-        }
+        self.tool_calls: dict[str, int] = {key: 0 for key in TOOL_METRIC_KEYS}
         self.augmentation_calls: int = 0
         self.augmentation_hits: int = 0
         self.augmentation_errors: int = 0

eval/analysis/analyze_results.py

@@ -27,6 +27,8 @@ import typer
 from rich.console import Console
 from rich.table import Table
 
+from tool_registry import TOOL_METRIC_KEYS
+
 logger = logging.getLogger("analyze_results")
 console = Console()
 app = typer.Typer(rich_markup_mode="rich", add_completion=False)
@@ -77,13 +79,20 @@ def load_run_results(results_dir: Path) -> dict[str, dict]:
 
 
 def parse_run_id(run_id: str) -> tuple[str, str]:
-    """Parse 'model_mode' into (model, mode)."""
-    # Handle multi-word model names like 'minimax-2.5'
-    # Modes are: baseline, mcp, augment, full
-    known_modes = {"baseline", "mcp", "augment", "full"}
-    parts = run_id.rsplit("_", 1)
-    if len(parts) == 2 and parts[1] in known_modes:
-        return parts[0], parts[1]
+    """Parse 'model_mode' into (model, mode) using known suffixes."""
+    # Match the longest known suffix first to avoid hyphen collisions in model names.
+    known_modes = [
+        "native_augment",
+        "native",
+        "baseline",
+        "mcp",
+        "augment",
+        "full",
+    ]
+    for mode in known_modes:
+        suffix = f"_{mode}"
+        if run_id.endswith(suffix):
+            return run_id[: -len(suffix)], mode
     return run_id, "unknown"
 
 
@@ -266,12 +275,17 @@ def compare_modes(
         _, mode = parse_run_id(run_id)
         metrics[mode] = compute_metrics(run_data)
 
+    mode_order = [
+        mode
+        for mode in ["baseline", "native", "native_augment", "mcp", "augment", "full"]
+        if mode in metrics
+    ] or sorted(metrics.keys())
+
     # Print comparison table
     table = Table(title=f"Mode Comparison: {model}")
     table.add_column("Metric", style="bold")
-    for mode in ["baseline", "mcp", "augment", "full"]:
-        if mode in metrics:
-            table.add_column(mode, justify="right")
+    for mode in mode_order:
+        table.add_column(mode, justify="right")
 
     rows = [
         ("Instances", "n_instances", "d"),
@@ -288,7 +302,7 @@ def compare_modes(
 
     for label, key, fmt in rows:
         values = []
-        for mode in ["baseline", "mcp", "augment", "full"]:
+        for mode in mode_order:
             if mode in metrics:
                 v = metrics[mode].get(key, 0)
                 if fmt == ".1%":
@@ -307,8 +321,8 @@ def compare_modes(
         baseline_calls = metrics["baseline"]["avg_api_calls"]
 
         table.add_section()
-        for mode in ["mcp", "augment", "full"]:
-            if mode not in metrics:
+        for mode in mode_order:
+            if mode == "baseline":
                 continue
             mode_cost = metrics[mode]["avg_cost"]
             mode_calls = metrics[mode]["avg_api_calls"]
@@ -340,10 +354,8 @@ def gitnexus_usage(
 
     table = Table(title="Tool Usage by Run")
     table.add_column("Run", style="bold")
-    table.add_column("query", justify="right")
-    table.add_column("context", justify="right")
-    table.add_column("impact", justify="right")
-    table.add_column("cypher", justify="right")
+    for key in TOOL_METRIC_KEYS:
+        table.add_column(key, justify="right")
     table.add_column("Total", justify="right")
     table.add_column("Augment Hits", justify="right")
 
@@ -353,7 +365,7 @@ def gitnexus_usage(
             continue
 
         # Aggregate tool calls across trajectories
-        tool_totals: dict[str, int] = {"query": 0, "context": 0, "impact": 0, "cypher": 0, "overview": 0}
+        tool_totals: dict[str, int] = {key: 0 for key in TOOL_METRIC_KEYS}
         augment_hits = 0
 
         for traj in run_data.get("trajectories", {}).values():
@@ -373,10 +385,7 @@ def gitnexus_usage(
         if total > 0 or augment_hits > 0:
             table.add_row(
                 run_id,
-                str(tool_totals.get("query", 0)),
-                str(tool_totals.get("context", 0)),
-                str(tool_totals.get("impact", 0)),
-                str(tool_totals.get("cypher", 0)),
+                *[str(tool_totals.get(key, 0)) for key in TOOL_METRIC_KEYS],
                 str(total),
                 str(augment_hits),
             )

eval/bridge/mcp_bridge.py

@@ -2,7 +2,7 @@
 MCP Bridge for GitNexus
 
 Starts the GitNexus MCP server as a subprocess and provides a Python interface
-to call MCP tools. Used by the bash wrapper scripts and the augmentation layer.
+to call MCP tools. Used by the bash wrapper scripts and the augmentation layer..
 
 The bridge communicates with the MCP server via stdio using the JSON-RPC protocol.
 """
@@ -17,6 +17,14 @@ import time
 from pathlib import Path
 from typing import Any
 
+from constants import (
+    MCP_FIND_GITNEXUS_FALLBACK_TIMEOUT_SECONDS,
+    MCP_FIND_GITNEXUS_TIMEOUT_SECONDS,
+    MCP_READ_TIMEOUT_SECONDS,
+    MCP_STOP_WAIT_SECONDS,
+)
+from utils.errors import is_debug_enabled, log_safe_exception
+
 logger = logging.getLogger("mcp_bridge")
 
 
@@ -78,7 +86,7 @@ class MCPBridge:
             return True
 
         except Exception as e:
-            logger.error(f"Failed to start MCP bridge: {e}")
+            log_safe_exception(logger, "Failed to start MCP bridge", e, include_debug=is_debug_enabled())
             self.stop()
             return False
 
@@ -86,9 +94,14 @@ class MCPBridge:
         """Stop the MCP server subprocess."""
         if self.process:
             try:
-                self.process.stdin.close()
+                if self.process.stdin:
+                    self.process.stdin.close()
+                if self.process.stdout:
+                    self.process.stdout.close()
+                if self.process.stderr:
+                    self.process.stderr.close()
                 self.process.terminate()
-                self.process.wait(timeout=5)
+                self.process.wait(timeout=MCP_STOP_WAIT_SECONDS)
             except Exception:
                 try:
                     self.process.kill()
@@ -146,7 +159,9 @@ class MCPBridge:
             try:
                 result = subprocess.run(
                     [cmd, "gitnexus", "--version"],
-                    capture_output=True, text=True, timeout=15,
+                    capture_output=True,
+                    text=True,
+                    timeout=MCP_FIND_GITNEXUS_TIMEOUT_SECONDS,
                     cwd=self.repo_path,
                 )
                 if result.returncode == 0:
@@ -158,7 +173,9 @@ class MCPBridge:
         try:
             result = subprocess.run(
                 ["gitnexus", "--version"],
-                capture_output=True, text=True, timeout=10,
+                capture_output=True,
+                text=True,
+                timeout=MCP_FIND_GITNEXUS_FALLBACK_TIMEOUT_SECONDS,
             )
             if result.returncode == 0:
                 return "gitnexus"
@@ -194,7 +211,7 @@ class MCPBridge:
             self.process.stdin.flush()
 
             # Read response
-            response = self._read_response(timeout=30)
+            response = self._read_response(timeout=MCP_READ_TIMEOUT_SECONDS)
             if response and response.get("id") == request_id:
                 if "error" in response:
                     logger.error(f"MCP error: {response['error']}")
@@ -203,7 +220,7 @@ class MCPBridge:
             return None
 
         except Exception as e:
-            logger.error(f"MCP request failed: {e}")
+            log_safe_exception(logger, "MCP request failed", e, include_debug=is_debug_enabled())
             return None
 
     def _send_notification(self, method: str, params: dict):
@@ -224,42 +241,67 @@ class MCPBridge:
             self.process.stdin.write(message.encode("utf-8"))
             self.process.stdin.flush()
         except Exception as e:
-            logger.error(f"MCP notification failed: {e}")
+            log_safe_exception(logger, "MCP notification failed", e, include_debug=is_debug_enabled())
 
-    def _read_response(self, timeout: float = 30) -> dict | None:
+    def _read_content_length(self, deadline: float) -> int | None:
+        """Read Content-Length header, returning the byte length or None."""
+        if not self.process or not self.process.stdout:
+            return None
+
+        header_line = b""
+        while time.time() < deadline:
+            byte = self.process.stdout.read(1)
+            if not byte:
+                return None
+            header_line += byte
+            if header_line.endswith(b"\r\n\r\n") or header_line.endswith(b"\n\n"):
+                break
+
+        if not header_line:
+            return None
+
+        header_str = header_line.decode("utf-8").strip()
+        for line in header_str.split("\r\n"):
+            if line.lower().startswith("content-length:"):
+                try:
+                    return int(line.split(":", 1)[1].strip())
+                except (ValueError, IndexError):
+                    return None
+        return None
+
+    def _read_body(self, content_length: int, deadline: float) -> bytes | None:
+        """Read a response body of the expected length before deadline."""
+        if not self.process or not self.process.stdout:
+            return None
+
+        remaining = content_length
+        chunks: list[bytes] = []
+
+        while remaining > 0 and time.time() < deadline:
+            chunk = self.process.stdout.read(remaining)
+            if not chunk:
+                return None
+            chunks.append(chunk)
+            remaining -= len(chunk)
+
+        if remaining > 0:
+            return None
+
+        return b"".join(chunks)
+
+    def _read_response(self, timeout: float = MCP_READ_TIMEOUT_SECONDS) -> dict | None:
         """Read a JSON-RPC response from the MCP server."""
         if not self.process or not self.process.stdout:
             return None
 
-        start = time.time()
-
         try:
-            while time.time() - start < timeout:
-                # Read Content-Length header
-                header_line = b""
-                while True:
-                    byte = self.process.stdout.read(1)
-                    if not byte:
-                        return None
-                    header_line += byte
-                    if header_line.endswith(b"\r\n\r\n"):
-                        break
-                    if header_line.endswith(b"\n\n"):
-                        break
-
-                # Parse content length
-                header_str = header_line.decode("utf-8").strip()
-                content_length = None
-                for line in header_str.split("\r\n"):
-                    if line.lower().startswith("content-length:"):
-                        content_length = int(line.split(":")[1].strip())
-                        break
-
+            deadline = time.time() + timeout
+            while time.time() < deadline:
+                content_length = self._read_content_length(deadline)
                 if content_length is None:
                     continue
 
-                # Read body
-                body = self.process.stdout.read(content_length)
+                body = self._read_body(content_length, deadline)
                 if not body:
                     return None
 
@@ -272,7 +314,7 @@ class MCPBridge:
             return None
 
         except Exception as e:
-            logger.error(f"Error reading MCP response: {e}")
+            log_safe_exception(logger, "Error reading MCP response", e, include_debug=is_debug_enabled())
             return None
 
 

eval/configs/models/claude-haiku.yaml

@@ -1,8 +1,8 @@
 # Claude Haiku 4.5 — fast, cheap, good baseline
 # Via OpenRouter (set OPENROUTER_API_KEY in .env)
 model:
-  model_name: "openrouter/anthropic/claude-haiku-4.5"
-  cost_tracking: "ignore_errors"
+  model_name: 'openrouter/anthropic/claude-haiku-4.5'
+  cost_tracking: 'ignore_errors'
   model_kwargs:
     max_tokens: 8192
     temperature: 0

eval/configs/models/claude-opus.yaml

@@ -2,8 +2,8 @@
 # Via OpenRouter (set OPENROUTER_API_KEY in .env)
 # To use Anthropic directly, change to: anthropic/claude-opus-4-20250514
 model:
-  model_name: "openrouter/anthropic/claude-opus-4"
-  cost_tracking: "ignore_errors"
+  model_name: 'openrouter/anthropic/claude-opus-4'
+  cost_tracking: 'ignore_errors'
   model_kwargs:
     max_tokens: 16384
     temperature: 0

eval/configs/models/claude-sonnet.yaml

@@ -2,8 +2,8 @@
 # Via OpenRouter (set OPENROUTER_API_KEY in .env)
 # To use Anthropic directly, change to: anthropic/claude-sonnet-4-20250514
 model:
-  model_name: "openrouter/anthropic/claude-sonnet-4"
-  cost_tracking: "ignore_errors"
+  model_name: 'openrouter/anthropic/claude-sonnet-4'
+  cost_tracking: 'ignore_errors'
   model_kwargs:
     max_tokens: 16384
     temperature: 0

eval/configs/models/deepseek-chat.yaml

@@ -1,9 +1,9 @@
 model: deepseek-ai/deepseek-chat
 provider: openrouter
 cost:
-  input: 0.14  # per 1M tokens
-  output: 0.28  # per 1M tokens
-  
+  input: 0.14 # per 1M tokens
+  output: 0.28 # per 1M tokens
+
 # Native DeepSeek API (direct)
 api_key: null
 base_url: null

eval/configs/models/deepseek-v3.yaml

@@ -1,9 +1,9 @@
 model: deepseek-ai/DeepSeek-V3
 provider: openrouter
 cost:
-  input: 0.27  # per 1M tokens
-  output: 1.10  # per 1M tokens
-  
+  input: 0.27 # per 1M tokens
+  output: 1.10 # per 1M tokens
+
 # Native DeepSeek API (direct)
 # Get your API key at: https://platform.deepseek.com/
 # Or use OpenRouter with: OPENROUTER_API_KEY

eval/configs/models/glm-4.7.yaml

@@ -1,7 +1,7 @@
 # GLM 4.7 — via OpenRouter (set OPENROUTER_API_KEY in .env)
 model:
-  model_name: "openrouter/zhipuai/glm-4.7"
-  cost_tracking: "ignore_errors"
+  model_name: 'openrouter/zhipuai/glm-4.7'
+  cost_tracking: 'ignore_errors'
   model_kwargs:
     max_tokens: 8192
     temperature: 0

eval/configs/models/glm-5.yaml

@@ -1,7 +1,7 @@
 # GLM 5 — via OpenRouter (set OPENROUTER_API_KEY in .env)
 model:
-  model_name: "openrouter/zhipuai/glm-5"
-  cost_tracking: "ignore_errors"
+  model_name: 'openrouter/zhipuai/glm-5'
+  cost_tracking: 'ignore_errors'
   model_kwargs:
     max_tokens: 8192
     temperature: 0

eval/configs/models/minimax-2.5.yaml

@@ -1,7 +1,7 @@
 # MiniMax M1 2.5 — via OpenRouter (set OPENROUTER_API_KEY in .env)
 model:
-  model_name: "openrouter/minimax/minimax-m1-2.5"
-  cost_tracking: "ignore_errors"
+  model_name: 'openrouter/minimax/minimax-m1-2.5'
+  cost_tracking: 'ignore_errors'
   model_kwargs:
     max_tokens: 8192
     temperature: 0

eval/configs/models/minimax-m2.1.yaml

@@ -3,9 +3,9 @@
 # The action_regex tells mini-swe-agent to parse ```bash blocks from responses.
 model:
   model_class: litellm_textbased
-  model_name: "openrouter/minimax/minimax-m2.5"
+  model_name: 'openrouter/minimax/minimax-m2.5'
   action_regex: "```(?:bash|mswea_bash_command)\\s*\\n(.*?)\\n```"
-  cost_tracking: "ignore_errors"
+  cost_tracking: 'ignore_errors'
   model_kwargs:
     max_tokens: 8192
     temperature: 0

eval/configs/modes/baseline.yaml

@@ -1,9 +1,9 @@
 # Baseline mode — no GitNexus, pure mini-swe-agent (control group)
 agent:
-  agent_class: "eval.agents.gitnexus_agent.GitNexusAgent"
-  gitnexus_mode: "baseline"
+  agent_class: 'eval.agents.gitnexus_agent.GitNexusAgent'
+  gitnexus_mode: 'baseline'
   step_limit: 30
   cost_limit: 3.0
 
 environment:
-  environment_class: "docker"
+  environment_class: 'docker'

eval/configs/modes/native.yaml

@@ -5,14 +5,14 @@
 #
 # Use this mode to isolate the value of explicit tools without grep augmentation.
 agent:
-  agent_class: "eval.agents.gitnexus_agent.GitNexusAgent"
-  gitnexus_mode: "native"
+  agent_class: 'eval.agents.gitnexus_agent.GitNexusAgent'
+  gitnexus_mode: 'native'
   step_limit: 30
   cost_limit: 3.0
   track_gitnexus_usage: true
 
 environment:
-  environment_class: "eval.environments.gitnexus_docker.GitNexusDockerEnvironment"
+  environment_class: 'eval.environments.gitnexus_docker.GitNexusDockerEnvironment'
   enable_gitnexus: true
   skip_embeddings: true
   gitnexus_timeout: 120

eval/configs/modes/native_augment.yaml

@@ -8,8 +8,8 @@
 #
 # The agent decides when to use explicit tools vs rely on enriched grep results.
 agent:
-  agent_class: "eval.agents.gitnexus_agent.GitNexusAgent"
-  gitnexus_mode: "native_augment"
+  agent_class: 'eval.agents.gitnexus_agent.GitNexusAgent'
+  gitnexus_mode: 'native_augment'
   step_limit: 30
   cost_limit: 3.0
   augment_timeout: 5.0
@@ -17,7 +17,7 @@ agent:
   track_gitnexus_usage: true
 
 environment:
-  environment_class: "eval.environments.gitnexus_docker.GitNexusDockerEnvironment"
+  environment_class: 'eval.environments.gitnexus_docker.GitNexusDockerEnvironment'
   enable_gitnexus: true
   skip_embeddings: true
   gitnexus_timeout: 120

eval/constants.py

@@ -0,0 +1,15 @@
+DEBUG_ENV_VAR = "GITNEXUS_EVAL_DEBUG"
+
+# GitNexus eval-server health checks
+EVAL_SERVER_HEALTH_RETRIES = 30
+EVAL_SERVER_HEALTH_INTERVAL_SECONDS = 0.5
+EVAL_SERVER_HEALTH_TIMEOUT_SECONDS = 3
+
+# MCP bridge timeouts
+MCP_FIND_GITNEXUS_TIMEOUT_SECONDS = 15
+MCP_FIND_GITNEXUS_FALLBACK_TIMEOUT_SECONDS = 10
+MCP_READ_TIMEOUT_SECONDS = 30
+MCP_STOP_WAIT_SECONDS = 5
+
+# Agent defaults
+AUGMENT_TIMEOUT_SECONDS = 5.0

eval/environments/gitnexus_docker.py

@@ -26,72 +26,20 @@ import shutil
 import time
 from pathlib import Path
 
+from constants import (
+    EVAL_SERVER_HEALTH_INTERVAL_SECONDS,
+    EVAL_SERVER_HEALTH_RETRIES,
+    EVAL_SERVER_HEALTH_TIMEOUT_SECONDS,
+)
 from minisweagent.environments.docker import DockerEnvironment
+from tool_registry import TOOL_SPECS, ToolScriptSpec
+from utils.errors import is_debug_enabled, log_safe_exception
 
 logger = logging.getLogger("gitnexus_docker")
 
 DEFAULT_CACHE_DIR = Path.home() / ".gitnexus-eval-cache"
 EVAL_SERVER_PORT = 4848
 
-# Standalone tool scripts installed into /usr/local/bin/ inside the container.
-# Each script calls the eval-server via curl, with a CLI fallback.
-# These are standalone — no sourcing, no env inheritance needed.
-
-TOOL_SCRIPT_QUERY = r'''#!/bin/bash
-PORT="${GITNEXUS_EVAL_PORT:-__PORT__}"
-query="$1"; task_ctx="${2:-}"; goal="${3:-}"
-[ -z "$query" ] && echo "Usage: gitnexus-query <query> [task_context] [goal]" && exit 1
-args="{\"query\": \"$query\""
-[ -n "$task_ctx" ] && args="$args, \"task_context\": \"$task_ctx\""
-[ -n "$goal" ] && args="$args, \"goal\": \"$goal\""
-args="$args}"
-result=$(curl -sf -X POST "http://127.0.0.1:${PORT}/tool/query" -H "Content-Type: application/json" -d "$args" 2>/dev/null)
-if [ $? -eq 0 ] && [ -n "$result" ]; then echo "$result"; exit 0; fi
-cd /testbed && npx gitnexus query "$query" 2>&1
-'''
-
-TOOL_SCRIPT_CONTEXT = r'''#!/bin/bash
-PORT="${GITNEXUS_EVAL_PORT:-__PORT__}"
-name="$1"; file_path="${2:-}"
-[ -z "$name" ] && echo "Usage: gitnexus-context <symbol_name> [file_path]" && exit 1
-args="{\"name\": \"$name\""
-[ -n "$file_path" ] && args="$args, \"file_path\": \"$file_path\""
-args="$args}"
-result=$(curl -sf -X POST "http://127.0.0.1:${PORT}/tool/context" -H "Content-Type: application/json" -d "$args" 2>/dev/null)
-if [ $? -eq 0 ] && [ -n "$result" ]; then echo "$result"; exit 0; fi
-cd /testbed && npx gitnexus context "$name" 2>&1
-'''
-
-TOOL_SCRIPT_IMPACT = r'''#!/bin/bash
-PORT="${GITNEXUS_EVAL_PORT:-__PORT__}"
-target="$1"; direction="${2:-upstream}"
-[ -z "$target" ] && echo "Usage: gitnexus-impact <symbol_name> [upstream|downstream]" && exit 1
-result=$(curl -sf -X POST "http://127.0.0.1:${PORT}/tool/impact" -H "Content-Type: application/json" -d "{\"target\": \"$target\", \"direction\": \"$direction\"}" 2>/dev/null)
-if [ $? -eq 0 ] && [ -n "$result" ]; then echo "$result"; exit 0; fi
-cd /testbed && npx gitnexus impact "$target" --direction "$direction" 2>&1
-'''
-
-TOOL_SCRIPT_CYPHER = r'''#!/bin/bash
-PORT="${GITNEXUS_EVAL_PORT:-__PORT__}"
-query="$1"
-[ -z "$query" ] && echo "Usage: gitnexus-cypher <cypher_query>" && exit 1
-result=$(curl -sf -X POST "http://127.0.0.1:${PORT}/tool/cypher" -H "Content-Type: application/json" -d "{\"query\": \"$query\"}" 2>/dev/null)
-if [ $? -eq 0 ] && [ -n "$result" ]; then echo "$result"; exit 0; fi
-cd /testbed && npx gitnexus cypher "$query" 2>&1
-'''
-
-TOOL_SCRIPT_AUGMENT = r'''#!/bin/bash
-cd /testbed && npx gitnexus augment "$1" 2>&1 || true
-'''
-
-TOOL_SCRIPT_OVERVIEW = r'''#!/bin/bash
-PORT="${GITNEXUS_EVAL_PORT:-__PORT__}"
-echo "=== Code Knowledge Graph Overview ==="
-result=$(curl -sf -X POST "http://127.0.0.1:${PORT}/tool/list_repos" -H "Content-Type: application/json" -d "{}" 2>/dev/null)
-if [ $? -eq 0 ] && [ -n "$result" ]; then echo "$result"; exit 0; fi
-cd /testbed && npx gitnexus list 2>&1
-'''
-
 
 class GitNexusDockerEnvironment(DockerEnvironment):
     """
@@ -133,7 +81,13 @@ class GitNexusDockerEnvironment(DockerEnvironment):
             try:
                 self._setup_gitnexus()
             except Exception as e:
-                logger.warning(f"GitNexus setup failed, continuing without it: {e}")
+                log_safe_exception(
+                    logger,
+                    "GitNexus setup failed, continuing without it",
+                    e,
+                    include_debug=is_debug_enabled(),
+                    level="warning",
+                )
                 self._gitnexus_ready = False
 
         return result
@@ -222,27 +176,59 @@ class GitNexusDockerEnvironment(DockerEnvironment):
             "timeout": 5,
         })
 
-        # Wait for the server to be ready (up to 15s for KuzuDB init)
-        for i in range(30):
-            time.sleep(0.5)
+        # Wait for the server to be ready (up to ~15s for KuzuDB init)
+        for i in range(EVAL_SERVER_HEALTH_RETRIES):
+            time.sleep(EVAL_SERVER_HEALTH_INTERVAL_SECONDS)
             health = self.execute({
                 "command": f"curl -sf http://127.0.0.1:{self.eval_server_port}/health 2>/dev/null || echo 'NOT_READY'",
-                "timeout": 3,
+                "timeout": EVAL_SERVER_HEALTH_TIMEOUT_SECONDS,
             })
             output = health.get("output", "").strip()
             if "NOT_READY" not in output and "ok" in output:
-                logger.info(f"Eval-server ready after {(i + 1) * 0.5:.1f}s")
+                logger.info(
+                    f"Eval-server ready after {(i + 1) * EVAL_SERVER_HEALTH_INTERVAL_SECONDS:.1f}s"
+                )
                 return
 
         log_output = self.execute({
             "command": "cat /tmp/gitnexus-eval-server.log 2>/dev/null | tail -20",
         })
         logger.warning(
-            f"Eval-server didn't become ready in 15s. "
+            f"Eval-server didn't become ready in "
+            f"{EVAL_SERVER_HEALTH_RETRIES * EVAL_SERVER_HEALTH_INTERVAL_SECONDS:.1f}s. "
             f"Tools will fall back to direct CLI.\n"
             f"Server log: {log_output.get('output', 'N/A')}"
         )
 
+    @staticmethod
+    def _render_tool_script(spec: ToolScriptSpec, port: str) -> str:
+        """
+        Render a standalone bash script for a GitNexus tool.
+
+        Scripts call the eval-server fast path when an endpoint is present,
+        and fall back to the CLI otherwise.
+        """
+        lines = ["#!/bin/bash"]
+
+        if spec.endpoint:
+            lines.append(f'PORT="${{GITNEXUS_EVAL_PORT:-{port}}}"')
+
+        if spec.header:
+            lines.append(spec.header.strip())
+
+        if spec.payload_builder:
+            lines.append(spec.payload_builder.strip())
+
+        if spec.endpoint:
+            lines.append(
+                f'result=$(curl -sf -X POST "http://127.0.0.1:${{PORT}}{spec.endpoint}" '
+                '-H "Content-Type: application/json" -d "$payload" 2>/dev/null)'
+            )
+            lines.append('if [ $? -eq 0 ] && [ -n "$result" ]; then echo "$result"; exit 0; fi')
+
+        lines.append(spec.fallback.strip())
+        return "\n".join(lines)
+
     def _install_tools(self):
         """
         Install standalone GitNexus tool scripts in /usr/local/bin/.
@@ -259,24 +245,20 @@ class GitNexusDockerEnvironment(DockerEnvironment):
         """
         port = str(self.eval_server_port)
 
-        tools = {
-            "gitnexus-query": TOOL_SCRIPT_QUERY,
-            "gitnexus-context": TOOL_SCRIPT_CONTEXT,
-            "gitnexus-impact": TOOL_SCRIPT_IMPACT,
-            "gitnexus-cypher": TOOL_SCRIPT_CYPHER,
-            "gitnexus-augment": TOOL_SCRIPT_AUGMENT,
-            "gitnexus-overview": TOOL_SCRIPT_OVERVIEW,
-        }
-
-        for name, script in tools.items():
-            script_content = script.replace("__PORT__", port).strip()
+        for spec in TOOL_SPECS.values():
+            script_content = self._render_tool_script(spec, port).strip()
             # Use heredoc with quoted delimiter — prevents all variable expansion and quoting issues
             self.execute({
-                "command": f"cat << 'GITNEXUS_SCRIPT_EOF' > /usr/local/bin/{name}\n{script_content}\nGITNEXUS_SCRIPT_EOF\nchmod +x /usr/local/bin/{name}",
+                "command": (
+                    f"cat << 'GITNEXUS_SCRIPT_EOF' > /usr/local/bin/{spec.bin_name}\n"
+                    f"{script_content}\n"
+                    "GITNEXUS_SCRIPT_EOF\n"
+                    f"chmod +x /usr/local/bin/{spec.bin_name}"
+                ),
                 "timeout": 5,
             })
 
-        logger.info(f"Installed {len(tools)} GitNexus tool scripts in /usr/local/bin/")
+        logger.info(f"Installed {len(TOOL_SPECS)} GitNexus tool scripts in /usr/local/bin/")
 
     def _get_repo_info(self) -> dict:
         """Get repository identity info from the container."""
@@ -325,7 +307,13 @@ class GitNexusDockerEnvironment(DockerEnvironment):
                     logger.info(f"Cached GitNexus index: {cache_path}")
 
         except Exception as e:
-            logger.warning(f"Failed to cache GitNexus index: {e}")
+            log_safe_exception(
+                logger,
+                "Failed to cache GitNexus index",
+                e,
+                include_debug=is_debug_enabled(),
+                level="warning",
+            )
             if cache_path.exists():
                 shutil.rmtree(cache_path, ignore_errors=True)
 
@@ -361,7 +349,13 @@ class GitNexusDockerEnvironment(DockerEnvironment):
                 logger.info("GitNexus index restored from cache")
 
         except Exception as e:
-            logger.warning(f"Failed to restore cache, re-indexing: {e}")
+            log_safe_exception(
+                logger,
+                "Failed to restore cache, re-indexing",
+                e,
+                include_debug=is_debug_enabled(),
+                level="warning",
+            )
             self._index_repository()
 
     def stop(self) -> dict:

eval/pyproject.toml

@@ -6,7 +6,7 @@ readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
     "mini-swe-agent>=2.0.0",
-    "litellm>=1.50.0",
+    "litellm>=1.50.0,!=1.82.7,!=1.82.8",
     "datasets>=3.0.0",
     "typer>=0.12.0",
     "rich>=13.0.0",
@@ -20,6 +20,8 @@ dependencies = [
 dev = [
     "pytest>=8.0.0",
     "ruff>=0.5.0",
+    "hypothesis>=6.88.0",
+    "coverage>=7.6.0",
 ]
 
 [project.scripts]
@@ -31,8 +33,8 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [tool.hatch.build.targets.wheel]
-packages = ["agents", "environments", "analysis", "bridge"]
-extra-files = ["run_eval.py"]
+packages = ["agents", "environments", "analysis", "bridge", "utils"]
+extra-files = ["run_eval.py", "tool_registry.py", "constants.py"]
 
 [tool.ruff]
 line-length = 120

eval/run_eval.py

@@ -25,7 +25,6 @@ import logging
 import os
 import threading
 import time
-import traceback
 from itertools import product
 from pathlib import Path
 from typing import Any
@@ -36,6 +35,8 @@ from rich.console import Console
 from rich.live import Live
 from rich.table import Table
 
+from utils.errors import is_debug_enabled, log_safe_exception
+
 # Load .env file from eval/ directory
 _env_file = Path(__file__).parent / ".env"
 if _env_file.exists():
@@ -138,6 +139,65 @@ def get_swebench_docker_image(instance: dict) -> str:
     return image_name
 
 
+def _build_model(config: dict):
+    """Construct the model from config."""
+    from minisweagent.models import get_model
+
+    return get_model(config=config.get("model", {}))
+
+
+def _build_environment(config: dict, instance: dict):
+    """Construct the environment for the instance."""
+    env_config = dict(config.get("environment", {}))
+    env_class_name = env_config.pop("environment_class", "docker")
+
+    if env_class_name == "eval.environments.gitnexus_docker.GitNexusDockerEnvironment":
+        from environments.gitnexus_docker import GitNexusDockerEnvironment
+
+        env_config["image"] = get_swebench_docker_image(instance)
+        return GitNexusDockerEnvironment(**env_config)
+
+    from minisweagent.environments.docker import DockerEnvironment
+
+    return DockerEnvironment(image=get_swebench_docker_image(instance), **env_config)
+
+
+def _build_agent(config: dict, model, env, instance_dir: Path, instance_id: str):
+    """Construct the GitNexus agent with trajectory output configured."""
+    from agents.gitnexus_agent import GitNexusAgent
+
+    agent_config = dict(config.get("agent", {}))
+    agent_config.pop("agent_class", "eval.agents.gitnexus_agent.GitNexusAgent")
+    traj_path = instance_dir / f"{instance_id}.traj.json"
+    agent_config["output_path"] = traj_path
+    return GitNexusAgent(model, env, **agent_config)
+
+
+def _extract_submission(env, info: dict, run_id: str) -> str:
+    """Pull the git diff patch from the container, falling back to the agent submission."""
+    try:
+        patch_output = env.execute({"command": "cd /testbed && git diff"})
+        return patch_output.get("output", "").strip()
+    except Exception as patch_err:
+        logger.warning(f"[{run_id}] Failed to extract patch: {patch_err}")
+        return info.get("submission", "")
+
+
+def _record_failure(run_id: str, instance_id: str, result: dict, error: Exception):
+    sanitized = log_safe_exception(
+        logger,
+        f"[{run_id}] Error on {instance_id}",
+        error,
+        include_debug=is_debug_enabled(),
+    )
+    result["exit_status"] = sanitized["error_type"]
+    result["error_type"] = sanitized["error_type"]
+    result["error_message"] = sanitized["error_message"]
+    result["error"] = sanitized["error_message"]
+    if "error_detail_debug" in sanitized:
+        result["error_detail_debug"] = sanitized["error_detail_debug"]
+
+
 def process_instance(
     instance: dict,
     config: dict,
@@ -149,8 +209,6 @@ def process_instance(
     Process a single SWE-bench instance with the given config.
     Returns result dict with instance_id, exit_status, submission, metrics.
     """
-    from minisweagent.models import get_model
-
     instance_id = instance["instance_id"]
     run_id = f"{model_name}_{mode_name}"
     instance_dir = output_dir / run_id / instance_id
@@ -168,31 +226,12 @@ def process_instance(
     }
 
     agent = None
+    env = None
 
     try:
-        # Build model
-        model = get_model(config=config.get("model", {}))
-
-        # Build environment
-        env_config = dict(config.get("environment", {}))
-        env_class_name = env_config.pop("environment_class", "docker")
-
-        if env_class_name == "eval.environments.gitnexus_docker.GitNexusDockerEnvironment":
-            from environments.gitnexus_docker import GitNexusDockerEnvironment
-            env_config["image"] = get_swebench_docker_image(instance)
-            env = GitNexusDockerEnvironment(**env_config)
-        else:
-            from minisweagent.environments.docker import DockerEnvironment
-            env = DockerEnvironment(image=get_swebench_docker_image(instance), **env_config)
-
-        # Build agent
-        agent_config = dict(config.get("agent", {}))
-        agent_class_name = agent_config.pop("agent_class", "eval.agents.gitnexus_agent.GitNexusAgent")
-
-        from agents.gitnexus_agent import GitNexusAgent
-        traj_path = instance_dir / f"{instance_id}.traj.json"
-        agent_config["output_path"] = traj_path
-        agent = GitNexusAgent(model, env, **agent_config)
+        model = _build_model(config)
+        env = _build_environment(config, instance)
+        agent = _build_agent(config, model, env, instance_dir, instance_id)
 
         # Run
         logger.info(f"[{run_id}] Starting {instance_id}")
@@ -204,18 +243,10 @@ def process_instance(
         result["gitnexus_metrics"] = agent.gitnexus_metrics.to_dict()
 
         # Extract git diff patch from the container (SWE-bench needs the model_patch)
-        try:
-            patch_output = env.execute({"command": "cd /testbed && git diff"})
-            result["submission"] = patch_output.get("output", "").strip()
-        except Exception as patch_err:
-            logger.warning(f"[{run_id}] Failed to extract patch: {patch_err}")
-            result["submission"] = info.get("submission", "")
+        result["submission"] = _extract_submission(env, info, run_id)
 
     except Exception as e:
-        logger.error(f"[{run_id}] Error on {instance_id}: {e}")
-        result["exit_status"] = type(e).__name__
-        result["error"] = str(e)
-        result["traceback"] = traceback.format_exc()
+        _record_failure(run_id, instance_id, result, e)
 
     finally:
         if agent:
@@ -287,7 +318,12 @@ def run_configuration(
                     results.append(future.result())
                 except Exception as e:
                     iid = futures[future]
-                    logger.error(f"[{run_id}] Uncaught error for {iid}: {e}")
+                    log_safe_exception(
+                        logger,
+                        f"[{run_id}] Uncaught error for {iid}",
+                        e,
+                        include_debug=is_debug_enabled(),
+                    )
 
     # Save run summary
     summary = {

eval/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for the GitNexus eval harness."""

eval/tests/conftest.py

@@ -0,0 +1,6 @@
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))

eval/tests/test_errors.py

@@ -0,0 +1,29 @@
+from utils.errors import sanitize_exception
+
+
+def _raise_value_error():
+    raise ValueError("boom")
+
+
+def test_sanitize_exception_without_debug(monkeypatch):
+    monkeypatch.delenv("GITNEXUS_EVAL_DEBUG", raising=False)
+    try:
+        _raise_value_error()
+    except Exception as exc:  # noqa: BLE001
+        data = sanitize_exception(exc, include_debug=False)
+
+    assert data["error_type"] == "ValueError"
+    assert data["error_message"] == "boom"
+    assert "error_detail_debug" not in data
+
+
+def test_sanitize_exception_with_debug(monkeypatch):
+    monkeypatch.setenv("GITNEXUS_EVAL_DEBUG", "1")
+    try:
+        _raise_value_error()
+    except Exception as exc:  # noqa: BLE001
+        data = sanitize_exception(exc)
+
+    assert data["error_type"] == "ValueError"
+    assert "error_detail_debug" in data
+    assert "ValueError" in data["error_detail_debug"]

eval/tests/test_parse_run_id.py

@@ -0,0 +1,20 @@
+import pytest
+
+analysis_module = pytest.importorskip("analysis.analyze_results")
+parse_run_id = analysis_module.parse_run_id
+
+
+def test_parse_run_id_native_augment():
+    model, mode = parse_run_id("claude-sonnet_native_augment")
+    assert model == "claude-sonnet"
+    assert mode == "native_augment"
+
+
+def test_parse_run_id_hyphenated_model():
+    model, mode = parse_run_id("glm-4.7_native")
+    assert model == "glm-4.7"
+    assert mode == "native"
+
+
+def test_parse_run_id_unknown():
+    assert parse_run_id("custom_model") == ("custom_model", "unknown")

eval/tests/test_property_based.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from hypothesis import given
+from hypothesis import strategies as st
+
+from analysis.analyze_results import parse_run_id
+from environments.gitnexus_docker import GitNexusDockerEnvironment
+from tool_registry import TOOL_SPECS
+from utils.errors import sanitize_exception
+
+
+KNOWN_MODES = [
+    "native_augment",
+    "native",
+    "baseline",
+    "mcp",
+    "augment",
+    "full",
+]
+
+
+def _model_strategy():
+    base_chars = st.characters(
+        blacklist_categories=("Cs",),
+        blacklist_characters={" ", "\n", "\t"},
+    )
+    text = st.text(alphabet=base_chars, min_size=1)
+    return text.filter(lambda s: not any(s.endswith(f"_{m}") for m in KNOWN_MODES))
+
+
+@given(_model_strategy(), st.sampled_from(KNOWN_MODES))
+def test_parse_run_id_round_trip(model: str, mode: str) -> None:
+    run_id = f"{model}_{mode}"
+    parsed_model, parsed_mode = parse_run_id(run_id)
+    assert parsed_model == model
+    assert parsed_mode == mode
+
+
+@given(st.text())
+def test_sanitize_exception_respects_debug_flag(message: str) -> None:
+    exc = ValueError(message)
+    data = sanitize_exception(exc, include_debug=False)
+    assert data["error_type"] == "ValueError"
+    assert data["error_message"] == (message or "ValueError")
+    assert "error_detail_debug" not in data
+
+    data_debug = sanitize_exception(exc, include_debug=True)
+    assert data_debug["error_type"] == "ValueError"
+    assert "error_detail_debug" in data_debug
+    assert data_debug["error_detail_debug"]
+
+
+@given(st.sampled_from(list(TOOL_SPECS.values())), st.integers(min_value=1, max_value=99999))
+def test_render_tool_script_contains_expected_paths(spec, port: int) -> None:
+    script = GitNexusDockerEnvironment._render_tool_script(spec, str(port))
+
+    assert spec.fallback.strip() in script
+    if spec.endpoint:
+        assert spec.endpoint in script
+        assert f"${{GITNEXUS_EVAL_PORT:-{port}}}" in script
+        assert "curl" in script
+    else:
+        assert "curl" not in script

eval/tests/test_tool_scripts.py

@@ -0,0 +1,21 @@
+import pytest
+
+GitNexusDockerEnvironment = pytest.importorskip(
+    "environments.gitnexus_docker"
+).GitNexusDockerEnvironment
+tool_registry = pytest.importorskip("tool_registry")
+TOOL_SPECS = tool_registry.TOOL_SPECS
+
+
+def test_render_query_script_uses_endpoint_and_fallback():
+    script = GitNexusDockerEnvironment._render_tool_script(TOOL_SPECS["query"], "4848")
+    assert "/tool/query" in script
+    assert "gitnexus query" in script
+    assert "GITNEXUS_EVAL_PORT" in script
+
+
+def test_render_augment_script_skips_curl():
+    script = GitNexusDockerEnvironment._render_tool_script(TOOL_SPECS["augment"], "4848")
+    assert "/tool/" not in script
+    assert "curl" not in script
+    assert "gitnexus augment" in script

eval/tool_registry.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Tuple
+
+
+@dataclass(frozen=True)
+class ToolScriptSpec:
+    key: str
+    bin_name: str
+    endpoint: str | None
+    payload_builder: str
+    fallback: str
+    header: str | None = None
+
+
+TOOL_METRIC_KEYS: Tuple[str, ...] = ("query", "context", "impact", "cypher", "overview")
+
+TOOL_SPECS: Dict[str, ToolScriptSpec] = {
+    "query": ToolScriptSpec(
+        key="query",
+        bin_name="gitnexus-query",
+        endpoint="/tool/query",
+        payload_builder=r'''query="$1"; task_ctx="${2:-}"; goal="${3:-}"
+[ -z "$query" ] && echo "Usage: gitnexus-query <query> [task_context] [goal]" && exit 1
+payload="{\"query\": \"$query\""
+[ -n "$task_ctx" ] && payload="$payload, \"task_context\": \"$task_ctx\""
+[ -n "$goal" ] && payload="$payload, \"goal\": \"$goal\""
+payload="$payload}"''',
+        fallback='cd /testbed && npx gitnexus query "$query" 2>&1',
+    ),
+    "context": ToolScriptSpec(
+        key="context",
+        bin_name="gitnexus-context",
+        endpoint="/tool/context",
+        payload_builder=r'''name="$1"; file_path="${2:-}"
+[ -z "$name" ] && echo "Usage: gitnexus-context <symbol_name> [file_path]" && exit 1
+payload="{\"name\": \"$name\""
+[ -n "$file_path" ] && payload="$payload, \"file_path\": \"$file_path\""
+payload="$payload}"''',
+        fallback='cd /testbed && npx gitnexus context "$name" 2>&1',
+    ),
+    "impact": ToolScriptSpec(
+        key="impact",
+        bin_name="gitnexus-impact",
+        endpoint="/tool/impact",
+        payload_builder=r'''target="$1"; direction="${2:-upstream}"
+[ -z "$target" ] && echo "Usage: gitnexus-impact <symbol_name> [upstream|downstream]" && exit 1
+payload="{\"target\": \"$target\", \"direction\": \"$direction\"}"''',
+        fallback='cd /testbed && npx gitnexus impact "$target" --direction "$direction" 2>&1',
+    ),
+    "cypher": ToolScriptSpec(
+        key="cypher",
+        bin_name="gitnexus-cypher",
+        endpoint="/tool/cypher",
+        payload_builder=r'''query="$1"
+[ -z "$query" ] && echo "Usage: gitnexus-cypher <cypher_query>" && exit 1
+payload="{\"query\": \"$query\"}"''',
+        fallback='cd /testbed && npx gitnexus cypher "$query" 2>&1',
+    ),
+    "overview": ToolScriptSpec(
+        key="overview",
+        bin_name="gitnexus-overview",
+        endpoint="/tool/list_repos",
+        header='echo "=== Code Knowledge Graph Overview ==="',
+        payload_builder='payload="{}"',
+        fallback='cd /testbed && npx gitnexus list 2>&1',
+    ),
+    "augment": ToolScriptSpec(
+        key="augment",
+        bin_name="gitnexus-augment",
+        endpoint=None,
+        payload_builder="",
+        fallback='cd /testbed && npx gitnexus augment "$1" 2>&1 || true',
+    ),
+}
+
+BINARIES_BY_KEY: Dict[str, str] = {spec.key: spec.bin_name for spec in TOOL_SPECS.values()}
+ENDPOINTS_BY_KEY: Dict[str, str | None] = {spec.key: spec.endpoint for spec in TOOL_SPECS.values()}

eval/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility package for the eval harness."""

eval/utils/errors.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import os
+import traceback
+from typing import Any, Callable
+
+from constants import DEBUG_ENV_VAR
+
+
+def is_debug_enabled() -> bool:
+    """Return True when debug output (full tracebacks) should be emitted."""
+    return os.getenv(DEBUG_ENV_VAR, "").strip().lower() in {"1", "true", "yes", "on"}
+
+
+def sanitize_exception(exc: BaseException, *, include_debug: bool | None = None) -> dict[str, str]:
+    """
+    Produce a log-safe, JSON-friendly view of an exception.
+
+    - Always returns error_type and error_message.
+    - Only includes error_detail_debug (full traceback) when debug is enabled.
+    """
+    debug = is_debug_enabled() if include_debug is None else include_debug
+
+    error_type = type(exc).__name__
+    message = str(exc) or error_type
+
+    data: dict[str, str] = {
+        "error_type": error_type,
+        "error_message": message,
+    }
+
+    if debug:
+        tb = "".join(traceback.format_exception(type(exc), exc, exc.__traceback__))
+        if tb:
+            data["error_detail_debug"] = tb
+
+    return data
+
+
+def log_safe_exception(
+    logger: Any,
+    prefix: str,
+    exc: BaseException,
+    *,
+    include_debug: bool | None = None,
+    level: str = "error",
+) -> dict[str, str]:
+    """
+    Log an exception without leaking stack traces unless debug is enabled.
+
+    Returns the sanitized dict so callers can persist it.
+    """
+    data = sanitize_exception(exc, include_debug=include_debug)
+    debug = "error_detail_debug" in data
+
+    log_fn: Callable[..., None] = getattr(logger, level, logger.error)
+    message = f"{prefix}: {data['error_type']}: {data['error_message']}"
+    log_kwargs = {"exc_info": True} if debug else {}
+    log_fn(message, **log_kwargs)
+    return data

gitnexus-claude-plugin/hooks/gitnexus-hook.js

@@ -64,10 +64,26 @@ function extractPattern(toolName, toolInput) {
     const tokens = cmd.split(/\s+/);
     let foundCmd = false;
     let skipNext = false;
-    const flagsWithValues = new Set(['-e', '-f', '-m', '-A', '-B', '-C', '-g', '--glob', '-t', '--type', '--include', '--exclude']);
+    const flagsWithValues = new Set([
+      '-e',
+      '-f',
+      '-m',
+      '-A',
+      '-B',
+      '-C',
+      '-g',
+      '--glob',
+      '-t',
+      '--type',
+      '--include',
+      '--exclude',
+    ]);
 
     for (const token of tokens) {
-      if (skipNext) { skipNext = false; continue; }
+      if (skipNext) {
+        skipNext = false;
+        continue;
+      }
       if (!foundCmd) {
         if (/\brg$|\bgrep$/.test(token)) foundCmd = true;
         continue;
@@ -98,33 +114,42 @@ function runGitNexusCli(args, cwd, timeout) {
   // Detect whether 'gitnexus' is on PATH (cheap check, no execution)
   let useDirectBinary = false;
   try {
-    const which = spawnSync(
-      isWin ? 'where' : 'which', ['gitnexus'],
-      { encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] }
-    );
+    const which = spawnSync(isWin ? 'where' : 'which', ['gitnexus'], {
+      encoding: 'utf-8',
+      timeout: 3000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
     useDirectBinary = which.status === 0;
-  } catch { /* not on PATH */ }
+  } catch {
+    /* not on PATH */
+  }
 
   if (useDirectBinary) {
-    return spawnSync(
-      isWin ? 'gitnexus.cmd' : 'gitnexus', args,
-      { encoding: 'utf-8', timeout, cwd, stdio: ['pipe', 'pipe', 'pipe'] }
-    );
+    return spawnSync(isWin ? 'gitnexus.cmd' : 'gitnexus', args, {
+      encoding: 'utf-8',
+      timeout,
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
   }
   // npx fallback needs shell on Windows since npx is a .cmd script
-  return spawnSync(
-    isWin ? 'npx.cmd' : 'npx', ['-y', 'gitnexus', ...args],
-    { encoding: 'utf-8', timeout: timeout + 5000, cwd, stdio: ['pipe', 'pipe', 'pipe'] }
-  );
+  return spawnSync(isWin ? 'npx.cmd' : 'npx', ['-y', 'gitnexus', ...args], {
+    encoding: 'utf-8',
+    timeout: timeout + 5000,
+    cwd,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
 }
 
 /**
  * Emit a hook response with additional context for the agent.
  */
 function sendHookResponse(hookEventName, message) {
-  console.log(JSON.stringify({
-    hookSpecificOutput: { hookEventName, additionalContext: message }
-  }));
+  console.log(
+    JSON.stringify({
+      hookSpecificOutput: { hookEventName, additionalContext: message },
+    }),
+  );
 }
 
 /**
@@ -149,7 +174,9 @@ function handlePreToolUse(input) {
     if (!child.error && child.status === 0) {
       result = child.stderr || '';
     }
-  } catch { /* graceful failure */ }
+  } catch {
+    /* graceful failure */
+  }
 
   if (result && result.trim()) {
     sendHookResponse('PreToolUse', result.trim());
@@ -185,10 +212,15 @@ function handlePostToolUse(input) {
   let currentHead = '';
   try {
     const headResult = spawnSync('git', ['rev-parse', 'HEAD'], {
-      encoding: 'utf-8', timeout: 3000, cwd, stdio: ['pipe', 'pipe', 'pipe'],
+      encoding: 'utf-8',
+      timeout: 3000,
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
     });
     currentHead = (headResult.stdout || '').trim();
-  } catch { return; }
+  } catch {
+    return;
+  }
 
   if (!currentHead) return;
 
@@ -197,16 +229,19 @@ function handlePostToolUse(input) {
   try {
     const meta = JSON.parse(fs.readFileSync(path.join(gitNexusDir, 'meta.json'), 'utf-8'));
     lastCommit = meta.lastCommit || '';
-    hadEmbeddings = (meta.stats && meta.stats.embeddings > 0);
-  } catch { /* no meta — treat as stale */ }
+    hadEmbeddings = meta.stats && meta.stats.embeddings > 0;
+  } catch {
+    /* no meta — treat as stale */
+  }
 
   // If HEAD matches last indexed commit, no reindex needed
   if (currentHead && currentHead === lastCommit) return;
 
   const analyzeCmd = `npx gitnexus analyze${hadEmbeddings ? ' --embeddings' : ''}`;
-  sendHookResponse('PostToolUse',
+  sendHookResponse(
+    'PostToolUse',
     `GitNexus index is stale (last indexed: ${lastCommit ? lastCommit.slice(0, 7) : 'never'}). ` +
-    `Run \`${analyzeCmd}\` to update the knowledge graph.`
+      `Run \`${analyzeCmd}\` to update the knowledge graph.`,
   );
 }
 

gitnexus-shared/package-lock.json

@@ -0,0 +1,29 @@
+{
+  "name": "gitnexus-shared",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "gitnexus-shared",
+      "version": "1.0.0",
+      "devDependencies": {
+        "typescript": "^6.0.2"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.2.tgz",
+      "integrity": "sha512-bGdAIrZ0wiGDo5l8c++HWtbaNCWTS4UTv7RaTH/ThVIgjkveJt83m74bBHMJkuCbslY8ixgLBVZJIOiQlQTjfQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    }
+  }
+}

gitnexus-shared/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "gitnexus-shared",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Shared type definitions for GitNexus CLI and web",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "devDependencies": {
+    "typescript": "^6.0.2"
+  }
+}

gitnexus-shared/src/graph/types.ts

@@ -0,0 +1,133 @@
+/**
+ * Graph type definitions — single source of truth.
+ *
+ * Both gitnexus (CLI) and gitnexus-web import from this package.
+ * Do NOT add Node.js-specific or browser-specific imports here.
+ */
+
+import { SupportedLanguages } from '../languages.js';
+
+export type NodeLabel =
+  | 'Project'
+  | 'Package'
+  | 'Module'
+  | 'Folder'
+  | 'File'
+  | 'Class'
+  | 'Function'
+  | 'Method'
+  | 'Variable'
+  | 'Interface'
+  | 'Enum'
+  | 'Decorator'
+  | 'Import'
+  | 'Type'
+  | 'CodeElement'
+  | 'Community'
+  | 'Process'
+  // Multi-language node types
+  | 'Struct'
+  | 'Macro'
+  | 'Typedef'
+  | 'Union'
+  | 'Namespace'
+  | 'Trait'
+  | 'Impl'
+  | 'TypeAlias'
+  | 'Const'
+  | 'Static'
+  | 'Property'
+  | 'Record'
+  | 'Delegate'
+  | 'Annotation'
+  | 'Constructor'
+  | 'Template'
+  | 'Section'
+  | 'Route'
+  | 'Tool';
+
+export type NodeProperties = {
+  name: string;
+  filePath: string;
+  startLine?: number;
+  endLine?: number;
+  language?: SupportedLanguages | string;
+  isExported?: boolean;
+  astFrameworkMultiplier?: number;
+  astFrameworkReason?: string;
+  // Community
+  heuristicLabel?: string;
+  cohesion?: number;
+  symbolCount?: number;
+  keywords?: string[];
+  description?: string;
+  enrichedBy?: 'heuristic' | 'llm';
+  // Process
+  processType?: 'intra_community' | 'cross_community';
+  stepCount?: number;
+  communities?: string[];
+  entryPointId?: string;
+  terminalId?: string;
+  entryPointScore?: number;
+  entryPointReason?: string;
+  // Method/property
+  parameterCount?: number;
+  level?: number;
+  returnType?: string;
+  declaredType?: string;
+  visibility?: string;
+  isStatic?: boolean;
+  isReadonly?: boolean;
+  isAbstract?: boolean;
+  isFinal?: boolean;
+  isVirtual?: boolean;
+  isOverride?: boolean;
+  isAsync?: boolean;
+  isPartial?: boolean;
+  annotations?: string[];
+  // Route/response
+  responseKeys?: string[];
+  errorKeys?: string[];
+  middleware?: string[];
+  // Extensible
+  [key: string]: unknown;
+};
+
+export type RelationshipType =
+  | 'CONTAINS'
+  | 'CALLS'
+  | 'INHERITS'
+  | 'OVERRIDES'
+  | 'IMPORTS'
+  | 'USES'
+  | 'DEFINES'
+  | 'DECORATES'
+  | 'IMPLEMENTS'
+  | 'EXTENDS'
+  | 'HAS_METHOD'
+  | 'HAS_PROPERTY'
+  | 'ACCESSES'
+  | 'MEMBER_OF'
+  | 'STEP_IN_PROCESS'
+  | 'HANDLES_ROUTE'
+  | 'FETCHES'
+  | 'HANDLES_TOOL'
+  | 'ENTRY_POINT_OF'
+  | 'WRAPS'
+  | 'QUERIES';
+
+export interface GraphNode {
+  id: string;
+  label: NodeLabel;
+  properties: NodeProperties;
+}
+
+export interface GraphRelationship {
+  id: string;
+  sourceId: string;
+  targetId: string;
+  type: RelationshipType;
+  confidence: number;
+  reason: string;
+  step?: number;
+}

gitnexus-shared/src/index.ts

@@ -0,0 +1,24 @@
+// Graph types
+export type {
+  NodeLabel,
+  NodeProperties,
+  RelationshipType,
+  GraphNode,
+  GraphRelationship,
+} from './graph/types.js';
+
+// Schema constants
+export {
+  NODE_TABLES,
+  REL_TABLE_NAME,
+  REL_TYPES,
+  EMBEDDING_TABLE_NAME,
+} from './lbug/schema-constants.js';
+export type { NodeTableName, RelType } from './lbug/schema-constants.js';
+
+// Language support
+export { SupportedLanguages } from './languages.js';
+export { getLanguageFromFilename, getSyntaxLanguageFromFilename } from './language-detection.js';
+
+// Pipeline progress
+export type { PipelinePhase, PipelineProgress } from './pipeline.js';

gitnexus-shared/src/language-detection.ts

@@ -0,0 +1,146 @@
+/**
+ * Language Detection — maps file paths to SupportedLanguages enum values.
+ *
+ * Shared between CLI (ingestion pipeline) and web (syntax highlighting).
+ *
+ * ADDING A NEW LANGUAGE:
+ * 1. Add enum member to SupportedLanguages in languages.ts
+ * 2. Add file extensions to EXTENSION_MAP below
+ * 3. TypeScript will error if you miss either step (exhaustive Record)
+ */
+
+import { SupportedLanguages } from './languages.js';
+
+/** Ruby extensionless filenames recognised as Ruby source */
+const RUBY_EXTENSIONLESS_FILES = new Set([
+  'Rakefile',
+  'Gemfile',
+  'Guardfile',
+  'Vagrantfile',
+  'Brewfile',
+]);
+
+/**
+ * Exhaustive map: every SupportedLanguages member → its file extensions.
+ *
+ * If a new language is added to the enum without adding an entry here,
+ * TypeScript emits a compile error: "Property 'NewLang' is missing in type..."
+ */
+const EXTENSION_MAP: Record<SupportedLanguages, readonly string[]> = {
+  [SupportedLanguages.JavaScript]: ['.js', '.jsx', '.mjs', '.cjs'],
+  [SupportedLanguages.TypeScript]: ['.ts', '.tsx', '.mts', '.cts'],
+  [SupportedLanguages.Python]: ['.py'],
+  [SupportedLanguages.Java]: ['.java'],
+  [SupportedLanguages.C]: ['.c'],
+  [SupportedLanguages.CPlusPlus]: ['.cpp', '.cc', '.cxx', '.h', '.hpp', '.hxx', '.hh'],
+  [SupportedLanguages.CSharp]: ['.cs'],
+  [SupportedLanguages.Go]: ['.go'],
+  [SupportedLanguages.Ruby]: ['.rb', '.rake', '.gemspec'],
+  [SupportedLanguages.Rust]: ['.rs'],
+  [SupportedLanguages.PHP]: ['.php', '.phtml', '.php3', '.php4', '.php5', '.php8'],
+  [SupportedLanguages.Kotlin]: ['.kt', '.kts'],
+  [SupportedLanguages.Swift]: ['.swift'],
+  [SupportedLanguages.Dart]: ['.dart'],
+  [SupportedLanguages.Cobol]: ['.cbl', '.cob', '.cpy', '.cobol'],
+} satisfies Record<SupportedLanguages, readonly string[]>; // Ensure exhaustiveness
+
+/** Pre-built reverse lookup: extension → language (built once at module load). */
+const extToLang = new Map<string, SupportedLanguages>();
+for (const [lang, exts] of Object.entries(EXTENSION_MAP) as [
+  SupportedLanguages,
+  readonly string[],
+][]) {
+  for (const ext of exts) {
+    extToLang.set(ext, lang);
+  }
+}
+
+/**
+ * Map file extension to SupportedLanguage enum.
+ * Returns null if the file extension is not recognized.
+ */
+export const getLanguageFromFilename = (filename: string): SupportedLanguages | null => {
+  // Fast path: check the extension map
+  const lastDot = filename.lastIndexOf('.');
+  if (lastDot >= 0) {
+    const ext = filename.slice(lastDot).toLowerCase();
+    const lang = extToLang.get(ext);
+    if (lang !== undefined) return lang;
+  }
+
+  // Ruby extensionless files (Rakefile, Gemfile, etc.)
+  const basename = filename.split('/').pop() || filename;
+  if (RUBY_EXTENSIONLESS_FILES.has(basename)) {
+    return SupportedLanguages.Ruby;
+  }
+
+  return null;
+};
+
+/**
+ * Exhaustive map: every SupportedLanguages member → Prism syntax identifier.
+ *
+ * If a new language is added to the enum without adding an entry here,
+ * TypeScript emits a compile error.
+ */
+const SYNTAX_MAP: Record<SupportedLanguages, string> = {
+  [SupportedLanguages.JavaScript]: 'javascript',
+  [SupportedLanguages.TypeScript]: 'typescript',
+  [SupportedLanguages.Python]: 'python',
+  [SupportedLanguages.Java]: 'java',
+  [SupportedLanguages.C]: 'c',
+  [SupportedLanguages.CPlusPlus]: 'cpp',
+  [SupportedLanguages.CSharp]: 'csharp',
+  [SupportedLanguages.Go]: 'go',
+  [SupportedLanguages.Ruby]: 'ruby',
+  [SupportedLanguages.Rust]: 'rust',
+  [SupportedLanguages.PHP]: 'php',
+  [SupportedLanguages.Kotlin]: 'kotlin',
+  [SupportedLanguages.Swift]: 'swift',
+  [SupportedLanguages.Dart]: 'dart',
+  [SupportedLanguages.Cobol]: 'cobol',
+} satisfies Record<SupportedLanguages, string>; // Ensure exhaustiveness
+
+/** Non-code file extensions → Prism-compatible syntax identifiers */
+const AUXILIARY_SYNTAX_MAP: Record<string, string> = {
+  json: 'json',
+  yaml: 'yaml',
+  yml: 'yaml',
+  md: 'markdown',
+  mdx: 'markdown',
+  html: 'markup',
+  htm: 'markup',
+  erb: 'markup',
+  xml: 'markup',
+  css: 'css',
+  scss: 'css',
+  sass: 'css',
+  sh: 'bash',
+  bash: 'bash',
+  zsh: 'bash',
+  sql: 'sql',
+  toml: 'toml',
+  ini: 'ini',
+  dockerfile: 'docker',
+};
+
+/** Extensionless filenames → Prism-compatible syntax identifiers */
+const AUXILIARY_BASENAME_MAP: Record<string, string> = {
+  Makefile: 'makefile',
+  Dockerfile: 'docker',
+};
+
+/**
+ * Map file path to a Prism-compatible syntax highlight language string.
+ * Covers all SupportedLanguages (code files) plus common non-code formats.
+ * Returns 'text' for unrecognised files.
+ */
+export const getSyntaxLanguageFromFilename = (filePath: string): string => {
+  const lang = getLanguageFromFilename(filePath);
+  if (lang) return SYNTAX_MAP[lang];
+  const ext = filePath.split('.').pop()?.toLowerCase();
+  if (ext && ext in AUXILIARY_SYNTAX_MAP) return AUXILIARY_SYNTAX_MAP[ext];
+  const basename = filePath.split('/').pop() || '';
+  if (basename in AUXILIARY_BASENAME_MAP) return AUXILIARY_BASENAME_MAP[basename];
+  return 'text';
+};

gitnexus-shared/src/languages.ts

@@ -0,0 +1,24 @@
+/**
+ * Supported language enum — single source of truth.
+ *
+ * Both CLI and web use this to identify which language a file/node belongs to.
+ * The CLI uses it throughout the ingestion pipeline; the web uses it for display.
+ */
+export enum SupportedLanguages {
+  JavaScript = 'javascript',
+  TypeScript = 'typescript',
+  Python = 'python',
+  Java = 'java',
+  C = 'c',
+  CPlusPlus = 'cpp',
+  CSharp = 'csharp',
+  Go = 'go',
+  Ruby = 'ruby',
+  Rust = 'rust',
+  PHP = 'php',
+  Kotlin = 'kotlin',
+  Swift = 'swift',
+  Dart = 'dart',
+  /** Standalone regex processor — no tree-sitter, no LanguageProvider. */
+  Cobol = 'cobol',
+}

gitnexus-shared/src/lbug/schema-constants.ts

@@ -0,0 +1,71 @@
+/**
+ * LadybugDB schema constants — single source of truth.
+ *
+ * NODE_TABLES and REL_TYPES define what the knowledge graph can contain.
+ * Both CLI and web must agree on these for data compatibility.
+ *
+ * Full DDL schemas remain in each package's own schema.ts because
+ * the CLI uses native LadybugDB and the web uses WASM.
+ */
+
+export const NODE_TABLES = [
+  'File',
+  'Folder',
+  'Function',
+  'Class',
+  'Interface',
+  'Method',
+  'CodeElement',
+  'Community',
+  'Process',
+  'Section',
+  'Struct',
+  'Enum',
+  'Macro',
+  'Typedef',
+  'Union',
+  'Namespace',
+  'Trait',
+  'Impl',
+  'TypeAlias',
+  'Const',
+  'Static',
+  'Property',
+  'Record',
+  'Delegate',
+  'Annotation',
+  'Constructor',
+  'Template',
+  'Module',
+  'Route',
+  'Tool',
+] as const;
+
+export type NodeTableName = (typeof NODE_TABLES)[number];
+
+export const REL_TABLE_NAME = 'CodeRelation';
+
+export const REL_TYPES = [
+  'CONTAINS',
+  'DEFINES',
+  'IMPORTS',
+  'CALLS',
+  'EXTENDS',
+  'IMPLEMENTS',
+  'HAS_METHOD',
+  'HAS_PROPERTY',
+  'ACCESSES',
+  'OVERRIDES',
+  'MEMBER_OF',
+  'STEP_IN_PROCESS',
+  'HANDLES_ROUTE',
+  'FETCHES',
+  'HANDLES_TOOL',
+  'ENTRY_POINT_OF',
+  'WRAPS',
+  'QUERIES',
+] as const;
+
+export type RelType = (typeof REL_TYPES)[number];
+
+export const EMBEDDING_TABLE_NAME = 'CodeEmbedding';

gitnexus-shared/src/pipeline.ts

@@ -0,0 +1,29 @@
+/**
+ * Pipeline progress types — shared between CLI and web.
+ */
+
+export type PipelinePhase =
+  | 'idle'
+  | 'extracting'
+  | 'structure'
+  | 'parsing'
+  | 'imports'
+  | 'calls'
+  | 'heritage'
+  | 'communities'
+  | 'processes'
+  | 'enriching'
+  | 'complete'
+  | 'error';
+
+export interface PipelineProgress {
+  phase: PipelinePhase;
+  percent: number;
+  message: string;
+  detail?: string;
+  stats?: {
+    filesProcessed: number;
+    totalFiles: number;
+    nodesCreated: number;
+  };
+}

gitnexus-shared/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "composite": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}

gitnexus-web/api/proxy.ts

@@ -1,104 +0,0 @@
-import type { VercelRequest, VercelResponse } from '@vercel/node';
-
-/**
- * CORS Proxy for isomorphic-git
- * 
- * isomorphic-git calls: /api/proxy?url=https://github.com/...
- */
-export default async function handler(req: VercelRequest, res: VercelResponse) {
-  // Handle CORS preflight
-  if (req.method === 'OPTIONS') {
-    res.setHeader('Access-Control-Allow-Origin', '*');
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, Git-Protocol, Accept');
-    res.status(200).end();
-    return;
-  }
-
-  // Get URL from query parameter
-  const { url } = req.query;
-  
-  if (!url || typeof url !== 'string') {
-    res.status(400).json({ error: 'Missing url query parameter' });
-    return;
-  }
-
-  // Only allow GitHub URLs for security
-  const allowedHosts = ['github.com', 'raw.githubusercontent.com'];
-  let parsedUrl: URL;
-  
-  try {
-    parsedUrl = new URL(url);
-  } catch {
-    res.status(400).json({ error: 'Invalid URL' });
-    return;
-  }
-  
-  if (!allowedHosts.some(host => parsedUrl.hostname.endsWith(host))) {
-    res.status(403).json({ error: 'Only GitHub URLs are allowed' });
-    return;
-  }
-
-  try {
-    const headers: Record<string, string> = {
-      'User-Agent': 'git/isomorphic-git',
-    };
-    
-    // Forward relevant headers
-    if (req.headers.authorization) {
-      headers['Authorization'] = req.headers.authorization as string;
-    }
-    if (req.headers['content-type']) {
-      headers['Content-Type'] = req.headers['content-type'] as string;
-    }
-    if (req.headers['git-protocol']) {
-      headers['Git-Protocol'] = req.headers['git-protocol'] as string;
-    }
-    if (req.headers.accept) {
-      headers['Accept'] = req.headers.accept as string;
-    }
-
-    // Get request body for POST requests
-    let body: Buffer | undefined;
-    if (req.method === 'POST') {
-      const chunks: Buffer[] = [];
-      for await (const chunk of req) {
-        chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
-      }
-      body = Buffer.concat(chunks);
-    }
-
-    const response = await fetch(url, {
-      method: req.method || 'GET',
-      headers,
-      body: body ? new Uint8Array(body) : undefined,
-    });
-
-    // Set CORS headers
-    res.setHeader('Access-Control-Allow-Origin', '*');
-    res.setHeader('Access-Control-Expose-Headers', '*');
-
-    // Forward response headers (except ones that cause issues)
-    const skipHeaders = [
-      'content-encoding', 
-      'transfer-encoding', 
-      'connection',
-      'www-authenticate', // IMPORTANT: Strip this to prevent browser's native auth popup!
-    ];
-    
-    response.headers.forEach((value, key) => {
-      if (!skipHeaders.includes(key.toLowerCase())) {
-        res.setHeader(key, value);
-      }
-    });
-
-    res.status(response.status);
-    const buffer = await response.arrayBuffer();
-    res.send(Buffer.from(buffer));
-    
-  } catch (error) {
-    console.error('Proxy error:', error);
-    res.status(500).json({ error: 'Proxy request failed', details: String(error) });
-  }
-}
-

gitnexus-web/e2e/debug-issues.spec.ts

@@ -0,0 +1,133 @@
+import { test, expect } from '@playwright/test';
+
+/**
+ * Debug harnesses for investigating specific UI issues.
+ * Excluded from `npm run test:e2e` via testIgnore in playwright.config.ts.
+ * Run directly: DEBUG_E2E=1 npx playwright test e2e/debug-issues.spec.ts
+ */
+const BACKEND_URL = process.env.BACKEND_URL ?? 'http://localhost:4747';
+const debugTest = process.env.DEBUG_E2E ? test : test.skip;
+
+async function connectToServer(page: import('@playwright/test').Page) {
+  page.on('console', (msg) => {
+    if (msg.type() === 'error') console.log(`[error] ${msg.text()}`);
+  });
+
+  await page.goto('/');
+  await page.getByText('Server').click();
+  const serverInput = page.locator('input[name="server-url-input"]');
+  await serverInput.fill(BACKEND_URL);
+  await page.getByRole('button', { name: /Connect/ }).click();
+  await expect(page.locator('[data-testid="status-ready"]')).toBeVisible({ timeout: 30_000 });
+  // Wait for LadybugDB to finish loading — poll isDatabaseReady via process list visibility
+  await expect(page.locator('[data-testid="status-ready"]')).toBeVisible({ timeout: 30_000 });
+}
+
+debugTest('debug: process view Reset View button', async ({ page }, testInfo) => {
+  await connectToServer(page);
+
+  // Open Processes tab
+  await page.getByRole('button', { name: 'Nexus AI' }).click();
+  await page.getByText('Processes').click();
+  await expect(page.getByText(/\d+ processes detected/)).toBeVisible({ timeout: 10_000 });
+
+  // Click View on the first Cross-Community process
+  // The View button has opacity-0 by default, use JS click to bypass
+  const viewButtons = page.locator('button:has-text("View")');
+  const count = await viewButtons.count();
+  console.log(`Found ${count} View buttons`);
+
+  // Use evaluate to click the first one regardless of visibility
+  await page.evaluate(() => {
+    const btns = document.querySelectorAll('button');
+    for (const btn of btns) {
+      if (btn.textContent?.trim() === 'View') {
+        btn.click();
+        return;
+      }
+    }
+  });
+
+  // Wait for modal to appear
+  const modal = page.locator('[data-testid="process-modal"]');
+  await expect(modal).toBeVisible({ timeout: 5_000 });
+
+  // Screenshot: modal should be open with flowchart
+  await page.screenshot({ path: testInfo.outputPath('debug-modal-open.png'), fullPage: true });
+
+  // Get the diagram's current transform
+  const diagramDiv = modal.locator('[style*="transform"]');
+  const transformBefore = await diagramDiv.getAttribute('style');
+  console.log('Transform BEFORE zoom:', transformBefore);
+
+  // Zoom in using the + button
+  const zoomInBtn = modal.getByRole('button', { name: /Zoom in/ });
+  await zoomInBtn.click();
+  await zoomInBtn.click();
+  await zoomInBtn.click();
+  // Wait for zoom animation to settle
+  await expect(async () => {
+    const t = await diagramDiv.getAttribute('style');
+    expect(t).not.toBe(transformBefore);
+  }).toPass({ timeout: 2_000 });
+
+  const transformAfterZoom = await diagramDiv.getAttribute('style');
+  console.log('Transform AFTER zoom:', transformAfterZoom);
+  await page.screenshot({ path: testInfo.outputPath('debug-modal-zoomed.png'), fullPage: true });
+
+  // Click Reset View
+  const resetBtn = modal.getByRole('button', { name: 'Reset View' });
+  await resetBtn.click();
+  // Wait for reset animation to settle
+  await expect(async () => {
+    const t = await diagramDiv.getAttribute('style');
+    expect(t).toBe(transformBefore);
+  }).toPass({ timeout: 2_000 });
+
+  const transformAfterReset = await diagramDiv.getAttribute('style');
+  console.log('Transform AFTER reset:', transformAfterReset);
+  await page.screenshot({
+    path: testInfo.outputPath('debug-modal-after-reset.png'),
+    fullPage: true,
+  });
+
+  // Verify transform actually changed back
+  expect(transformAfterZoom).not.toBe(transformBefore);
+  expect(transformAfterReset).toBe(transformBefore);
+});
+
+debugTest('debug: lightbulb clears node selection dimming', async ({ page }, testInfo) => {
+  await connectToServer(page);
+
+  // Wait for graph canvas to render
+  await expect(page.locator('canvas').first()).toBeVisible({ timeout: 10_000 });
+
+  await page.screenshot({ path: testInfo.outputPath('debug-before-select.png'), fullPage: true });
+
+  // Click a file in the tree to select a node (causes dimming)
+  const fileItem = page.getByText('start.sh');
+  await fileItem.click();
+  await page.waitForTimeout(500);
+  await page.screenshot({ path: testInfo.outputPath('debug-node-selected.png'), fullPage: true });
+
+  // Check the lightbulb button state
+  const lightbulbBtn = page.locator('button[title*="Turn off"], button[title*="Turn on"]');
+  const title = await lightbulbBtn.getAttribute('title');
+  console.log('Lightbulb title before click:', title);
+
+  // Click the lightbulb
+  await lightbulbBtn.click();
+  await page.waitForTimeout(500);
+
+  const titleAfter = await lightbulbBtn.getAttribute('title');
+  console.log('Lightbulb title after click:', titleAfter);
+  await page.screenshot({ path: testInfo.outputPath('debug-after-lightbulb.png'), fullPage: true });
+
+  // Click it again to toggle back on
+  await lightbulbBtn.click();
+  await page.waitForTimeout(500);
+  await page.screenshot({
+    path: testInfo.outputPath('debug-after-lightbulb-toggle-back.png'),
+    fullPage: true,
+  });
+});

gitnexus-web/e2e/manual-record.spec.ts

@@ -0,0 +1,28 @@
+import { test } from '@playwright/test';
+
+/**
+ * Manual recording session for interactive debugging.
+ * Opens the app and pauses so you can interact with the UI.
+ * Trace, video, and screenshots are saved automatically on close.
+ *
+ * Run with: npx playwright test e2e/manual-record.spec.ts --headed --timeout=0
+ *
+ * Excluded from `npm run test:e2e` via testIgnore in playwright.config.ts.
+ * Also skipped when PWDEBUG is not set or in CI, as a safety net.
+ */
+test.skip(
+  !!process.env.CI || process.env.PWDEBUG !== '1',
+  'Manual recording requires --headed and PWDEBUG=1. Run: PWDEBUG=1 npx playwright test e2e/manual-record.spec.ts --headed --timeout=0',
+);
+
+test('manual recording session', async ({ page }) => {
+  page.on('console', (msg) => {
+    if (msg.type() === 'error' || msg.type() === 'warning') {
+      console.log(`[${msg.type()}] ${msg.text()}`);
+    }
+  });
+  page.on('pageerror', (err) => console.log(`[crash] ${err.message}`));
+
+  await page.goto('http://localhost:5173');
+  await page.pause();
+});

gitnexus-web/e2e/onboarding.spec.ts

@@ -0,0 +1,300 @@
+import { test, expect } from '@playwright/test';
+
+/**
+ * E2E tests for the onboarding and analysis user flows.
+ *
+ * These tests cover:
+ *   - Flow 1: OnboardingGuide shown when no server is running
+ *   - Flow 2: Analyze form when server has zero repos
+ *   - Flow 3: Auto-connect when server has repos
+ *   - Flow 4: Repo dropdown in exploring view
+ *
+ * Most tests mock the backend at the network level so they don't
+ * require a live gitnexus server.
+ */
+
+const BACKEND_URL = 'http://localhost:4747';
+
+async function enterExploringView(page: import('@playwright/test').Page) {
+  await page.goto('/');
+
+  const landingCard = page.locator('[data-testid="landing-repo-card"]').first();
+  try {
+    await landingCard.waitFor({ state: 'visible', timeout: 15_000 });
+    await landingCard.click();
+  } catch {
+    // Landing screen may not appear (e.g. ?server auto-connect)
+  }
+
+  await expect(page.locator('[data-testid="status-ready"]')).toBeVisible({ timeout: 30_000 });
+}
+
+// ── Flow 1: Onboarding (no server running) ─────────────────────────────────
+
+test.describe('Flow 1: Onboarding — no server', () => {
+  test('shows OnboardingGuide when backend is unreachable', async ({ page }, testInfo) => {
+    // Block all requests to the backend so the probe fails
+    await page.route(`${BACKEND_URL}/**`, (route) => route.abort('connectionrefused'));
+
+    await page.goto('/');
+
+    // Wait for initial probe to complete and onboarding to appear
+    await expect(page.getByText('Start your local server')).toBeVisible({ timeout: 10_000 });
+    await page.screenshot({ path: testInfo.outputPath('onboarding-visible.png') });
+  });
+
+  test('shows step-by-step instructions', async ({ page }) => {
+    await page.route(`${BACKEND_URL}/**`, (route) => route.abort('connectionrefused'));
+    await page.goto('/');
+
+    // Step 1 is active (done once polling starts)
+    await expect(page.getByText('Copy the command')).toBeAttached({ timeout: 10_000 });
+    // Step 2 title changes to "Waiting for server to start" once polling begins
+    await expect(page.getByText('Waiting for server to start')).toBeAttached({ timeout: 10_000 });
+    // Step 3 is always rendered
+    await expect(page.getByText('Auto-connects and opens the graph')).toBeAttached({
+      timeout: 5_000,
+    });
+  });
+
+  test('shows terminal window with command', async ({ page }) => {
+    await page.route(`${BACKEND_URL}/**`, (route) => route.abort('connectionrefused'));
+    await page.goto('/');
+
+    // Should show either dev or prod command in a terminal block
+    const terminal = page.locator('code');
+    await expect(terminal.first()).toBeVisible({ timeout: 10_000 });
+
+    // The $ prompt should be present
+    await expect(page.getByText('$')).toBeVisible();
+  });
+
+  test('shows polling indicator', async ({ page }) => {
+    await page.route(`${BACKEND_URL}/**`, (route) => route.abort('connectionrefused'));
+    await page.goto('/');
+
+    // Polling starts after initial probe fails
+    await expect(page.getByText('Listening for server')).toBeVisible({ timeout: 10_000 });
+  });
+
+  test('shows Node.js version requirement', async ({ page }) => {
+    await page.route(`${BACKEND_URL}/**`, (route) => route.abort('connectionrefused'));
+    await page.goto('/');
+
+    await expect(page.getByText(/Node\.js.*\d+/)).toBeVisible({ timeout: 10_000 });
+    await expect(page.getByText('Port 4747')).toBeVisible();
+  });
+
+  test('copy button has accessible label', async ({ page }) => {
+    await page.route(`${BACKEND_URL}/**`, (route) => route.abort('connectionrefused'));
+    await page.goto('/');
+
+    await expect(page.getByText('Copy the command')).toBeVisible({ timeout: 10_000 });
+    const copyBtn = page.getByLabel('Copy to clipboard').first();
+    await expect(copyBtn).toBeVisible();
+  });
+});
+
+// ── Flow 2: Server detected → success → auto-connect ──────────────────────
+
+test.describe('Flow 2: Server detected — auto-connect', () => {
+  test('shows success card when server becomes reachable', async ({ page }, testInfo) => {
+    // Start with server unreachable
+    let blockBackend = true;
+    await page.route(`${BACKEND_URL}/**`, (route) => {
+      if (blockBackend) return route.abort('connectionrefused');
+      // Let it through to the real handler below
+      return route.fallback();
+    });
+
+    // Mock the backend responses for when we "start" the server
+    await page.route(`${BACKEND_URL}/api/repos`, async (route) => {
+      if (blockBackend) return route.abort('connectionrefused');
+      await route.fulfill({ json: [{ name: 'test-repo', path: '/tmp/test' }] });
+    });
+    await page.route(`${BACKEND_URL}/api/repo`, async (route) => {
+      if (blockBackend) return route.abort('connectionrefused');
+      await route.fulfill({
+        json: { name: 'test-repo', path: '/tmp/test', repoPath: '/tmp/test' },
+      });
+    });
+    await page.route(`${BACKEND_URL}/api/graph**`, async (route) => {
+      if (blockBackend) return route.abort('connectionrefused');
+      await route.fulfill({ json: { nodes: [], relationships: [] } });
+    });
+    await page.route(`${BACKEND_URL}/api/heartbeat`, async (route) => {
+      if (blockBackend) return route.abort('connectionrefused');
+      // SSE response
+      await route.fulfill({
+        status: 200,
+        headers: { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache' },
+        body: ':ok\n\n',
+      });
+    });
+
+    await page.goto('/');
+
+    // Verify onboarding is shown first
+    await expect(page.getByText('Start your local server')).toBeVisible({ timeout: 10_000 });
+    await page.screenshot({ path: testInfo.outputPath('before-server-start.png') });
+
+    // "Start" the server by unblocking requests
+    blockBackend = false;
+
+    // Wait for success card
+    await expect(page.getByText('Server Connected')).toBeVisible({ timeout: 15_000 });
+    await page.screenshot({ path: testInfo.outputPath('success-card.png') });
+  });
+
+  test('transitions to analyze phase when server has zero repos', async ({ page }, testInfo) => {
+    // Mock server with zero repos — repos endpoint returns empty array
+    await page.route(`${BACKEND_URL}/api/repos`, (route) => route.fulfill({ json: [] }));
+    await page.route(`${BACKEND_URL}/api/info`, (route) =>
+      route.fulfill({ json: { version: '1.0.0', launchContext: 'npx', nodeVersion: 'v22.0.0' } }),
+    );
+    await page.route(`${BACKEND_URL}/api/heartbeat`, (route) =>
+      route.fulfill({
+        status: 200,
+        headers: { 'Content-Type': 'text/event-stream' },
+        body: ':ok\n\n',
+      }),
+    );
+
+    await page.goto('/');
+
+    // Should transition: onboarding → success → analyze (zero repos)
+    // The analyze form tabs should be visible
+    await expect(page.getByRole('tab', { name: 'GitHub URL' })).toBeVisible({ timeout: 20_000 });
+    await expect(page.getByRole('tab', { name: 'Local Folder' })).toBeVisible();
+    await page.screenshot({ path: testInfo.outputPath('analyze-empty-state.png') });
+  });
+});
+
+// ── Flow 3: Analyze form ───────────────────────────────────────────────────
+
+test.describe('Flow 3: Analyze form', () => {
+  test.beforeEach(async ({ page }) => {
+    // Mock server with zero repos to show the analyze form
+    await page.route(`${BACKEND_URL}/api/repos`, (route) => route.fulfill({ json: [] }));
+    await page.route(`${BACKEND_URL}/api/info`, (route) =>
+      route.fulfill({ json: { version: '1.0.0', launchContext: 'npx', nodeVersion: 'v22.0.0' } }),
+    );
+    await page.route(`${BACKEND_URL}/api/heartbeat`, (route) =>
+      route.fulfill({
+        status: 200,
+        headers: { 'Content-Type': 'text/event-stream' },
+        body: ':ok\n\n',
+      }),
+    );
+  });
+
+  test('GitHub URL tab validates input', async ({ page }, testInfo) => {
+    await page.goto('/');
+
+    // Wait for analyze form (transition: onboarding → success → analyze)
+    await expect(page.getByRole('tab', { name: 'GitHub URL' })).toBeVisible({ timeout: 20_000 });
+
+    // Type an invalid URL
+    const input = page.locator('input[type="url"]');
+    await input.fill('not-a-url');
+
+    // Analyze button should be visible but disabled
+    const analyzeBtn = page.getByRole('button', { name: /Analyze Repository/ });
+    await expect(analyzeBtn).toBeVisible();
+
+    // Type a valid GitHub URL
+    await input.fill('https://github.com/anthropics/courses');
+    await page.screenshot({ path: testInfo.outputPath('valid-github-url.png') });
+  });
+
+  test('Local Folder tab shows browse button', async ({ page }, testInfo) => {
+    await page.goto('/');
+
+    await expect(page.getByRole('tab', { name: 'Local Folder' })).toBeVisible({ timeout: 20_000 });
+
+    // Switch to Local Folder tab
+    await page.getByRole('tab', { name: 'Local Folder' }).click();
+
+    // Browse button should be visible
+    await expect(page.getByText('Browse for folder')).toBeVisible();
+    await page.screenshot({ path: testInfo.outputPath('local-folder-tab.png') });
+  });
+
+  test('switching tabs clears input', async ({ page }) => {
+    await page.goto('/');
+
+    await expect(page.getByRole('tab', { name: 'GitHub URL' })).toBeVisible({ timeout: 20_000 });
+
+    // Type in GitHub URL
+    const urlInput = page.locator('input[type="url"]');
+    await urlInput.fill('https://github.com/test/repo');
+
+    // Switch to Local Folder
+    await page.getByRole('tab', { name: 'Local Folder' }).click();
+
+    // Switch back to GitHub URL — input should be empty
+    await page.getByRole('tab', { name: 'GitHub URL' }).click();
+    const newUrlInput = page.locator('input[type="url"]');
+    await expect(newUrlInput).toHaveValue('');
+  });
+});
+
+// ── Flow 4: Repo dropdown (requires running server) ────────────────────────
+
+test.describe('Flow 4: Repo dropdown in exploring view', () => {
+  const SKIP_MSG = 'Requires running gitnexus server with indexed repos';
+
+  test.beforeAll(async () => {
+    if (process.env.E2E) return;
+    try {
+      const res = await fetch(`${BACKEND_URL}/api/repos`);
+      if (!res.ok) {
+        test.skip(true, SKIP_MSG);
+        return;
+      }
+      const repos = await res.json();
+      if (!repos.length) {
+        test.skip(true, 'Server has no indexed repos');
+        return;
+      }
+    } catch {
+      test.skip(true, SKIP_MSG);
+    }
+  });
+
+  test('project badge opens repo dropdown', async ({ page }, testInfo) => {
+    await enterExploringView(page);
+    await page.screenshot({ path: testInfo.outputPath('exploring-loaded.png') });
+
+    // Click the project badge (has a chevron)
+    const badge = page
+      .locator('header button')
+      .filter({ has: page.locator('svg') })
+      .first();
+    await badge.click();
+
+    // Repo dropdown should be visible
+    await expect(page.getByText('Repositories')).toBeVisible({ timeout: 5_000 });
+    await expect(page.getByText('Analyze a new repository')).toBeVisible();
+    await page.screenshot({ path: testInfo.outputPath('repo-dropdown-open.png') });
+  });
+
+  test('analyze option opens inline form', async ({ page }, testInfo) => {
+    await enterExploringView(page);
+
+    // Open repo dropdown
+    const badge = page
+      .locator('header button')
+      .filter({ has: page.locator('svg') })
+      .first();
+    await badge.click();
+
+    // Click "Analyze a new repository..."
+    await page.getByText('Analyze a new repository').click();
+
+    // Should show the analyze form inline
+    await expect(page.getByText('GitHub URL')).toBeVisible({ timeout: 5_000 });
+    await expect(page.getByText('Local Folder')).toBeVisible();
+    await page.screenshot({ path: testInfo.outputPath('inline-analyze-form.png') });
+  });
+});

gitnexus-web/e2e/server-connect.spec.ts

@@ -0,0 +1,165 @@
+import { test, expect, type TestInfo } from '@playwright/test';
+
+/**
+ * E2E tests for the GitNexus web UI — exploring view features.
+ *
+ * Requires:
+ *   - gitnexus serve running on localhost:4747 with at least one indexed repo
+ *   - gitnexus-web dev server running on localhost:5173
+ *
+ * Skipped when servers aren't available (CI without services, etc.).
+ * Set E2E=1 to force-run even without the availability check.
+ */
+
+const BACKEND_URL = process.env.BACKEND_URL ?? 'http://localhost:4747';
+const FRONTEND_URL = process.env.FRONTEND_URL ?? 'http://localhost:5173';
+
+test.beforeAll(async () => {
+  if (process.env.E2E) return;
+  try {
+    const [backendRes, frontendRes] = await Promise.allSettled([
+      fetch(`${BACKEND_URL}/api/repos`),
+      fetch(FRONTEND_URL),
+    ]);
+    if (
+      backendRes.status === 'rejected' ||
+      (backendRes.status === 'fulfilled' && !backendRes.value.ok)
+    ) {
+      test.skip(true, 'gitnexus serve not available on :4747');
+      return;
+    }
+    if (
+      frontendRes.status === 'rejected' ||
+      (frontendRes.status === 'fulfilled' && !frontendRes.value.ok)
+    ) {
+      test.skip(true, 'Vite dev server not available on :5173');
+      return;
+    }
+    // Check there's at least one indexed repo
+    if (backendRes.status === 'fulfilled') {
+      const repos = await backendRes.value.json();
+      if (!repos.length) {
+        test.skip(true, 'No indexed repos — run gitnexus analyze first');
+        return;
+      }
+    }
+  } catch {
+    test.skip(true, 'servers not available');
+  }
+});
+
+/**
+ * Wait for the server-detection flow to complete.
+ *
+ * The app auto-detects the server, then either:
+ *   - shows the landing screen when indexed repos exist, or
+ *   - goes straight into analyze onboarding when there are zero repos.
+ *
+ * For these tests we require at least one indexed repo, so pick the first
+ * landing card when present and then wait for the exploring view.
+ */
+async function waitForGraphLoaded(page: import('@playwright/test').Page, testInfo: TestInfo) {
+  await page.goto('/');
+
+  const landingCard = page.locator('[data-testid="landing-repo-card"]').first();
+  try {
+    await landingCard.waitFor({ state: 'visible', timeout: 15_000 });
+    await landingCard.click();
+  } catch {
+    // Landing screen may not appear (e.g. ?server auto-connect)
+  }
+
+  await expect(page.locator('[data-testid="status-ready"]')).toBeVisible({ timeout: 30_000 });
+  await expect(page.getByText(/\d+ nodes/).first()).toBeVisible();
+  await page.screenshot({ path: testInfo.outputPath('graph-loaded.png') });
+}
+
+test.describe('Server Connection & Graph Loading', () => {
+  test('selects a repo from landing and loads graph', async ({ page }, testInfo) => {
+    await waitForGraphLoaded(page, testInfo);
+    await page.screenshot({ path: testInfo.outputPath('graph-loaded-full.png'), fullPage: true });
+  });
+});
+
+test.describe('Nexus AI', () => {
+  test('panel opens and agent initializes without error', async ({ page }, testInfo) => {
+    await waitForGraphLoaded(page, testInfo);
+
+    await page.getByRole('button', { name: 'Nexus AI' }).click();
+    await expect(page.getByText('Ask me anything')).toBeVisible({ timeout: 15_000 });
+    await page.screenshot({ path: testInfo.outputPath('nexus-ai-panel.png'), fullPage: true });
+
+    const errorBanner = page.getByText('Database not ready');
+    expect(await errorBanner.isVisible().catch(() => false)).toBe(false);
+  });
+});
+
+test.describe('Processes Panel', () => {
+  test('shows process list and View button works', async ({ page }, testInfo) => {
+    await waitForGraphLoaded(page, testInfo);
+
+    await page.getByRole('button', { name: 'Nexus AI' }).click();
+    await page.getByText('Processes').click();
+
+    await expect(page.locator('[data-testid="process-list-loaded"]')).toBeVisible({
+      timeout: 15_000,
+    });
+    await page.screenshot({ path: testInfo.outputPath('processes-panel.png'), fullPage: true });
+
+    const processRow = page.locator('[data-testid="process-row"]').first();
+    await expect(processRow).toBeVisible({ timeout: 10_000 });
+    await processRow.hover();
+
+    const viewBtn = processRow.locator('[data-testid="process-view-button"]');
+    await viewBtn.waitFor({ state: 'visible', timeout: 5_000 });
+    await viewBtn.click();
+    await expect(page.locator('[data-testid="process-modal"]')).toBeVisible({ timeout: 5_000 });
+    await page.screenshot({
+      path: testInfo.outputPath('process-view-clicked.png'),
+      fullPage: true,
+    });
+  });
+
+  test('lightbulb highlights nodes in graph', async ({ page }, testInfo) => {
+    await waitForGraphLoaded(page, testInfo);
+
+    await page.getByRole('button', { name: 'Nexus AI' }).click();
+    await page.getByText('Processes').click();
+    await expect(page.locator('[data-testid="process-list-loaded"]')).toBeVisible({
+      timeout: 15_000,
+    });
+
+    const processRow = page.locator('[data-testid="process-row"]').first();
+    await expect(processRow).toBeVisible({ timeout: 10_000 });
+    await processRow.hover();
+
+    const lightbulb = processRow.locator('[data-testid="process-highlight-button"]');
+    await lightbulb.waitFor({ state: 'visible', timeout: 5_000 });
+    await lightbulb.click();
+    await expect(processRow).toHaveClass(/bg-amber-950/, { timeout: 5_000 });
+    await page.screenshot({ path: testInfo.outputPath('after-highlight.png'), fullPage: true });
+  });
+});
+
+test.describe('Turn Off All Highlights', () => {
+  test('selecting a node dims others, button clears it', async ({ page }, testInfo) => {
+    await waitForGraphLoaded(page, testInfo);
+
+    await expect(page.locator('canvas').first()).toBeVisible({ timeout: 10_000 });
+
+    const fileItem = page.getByText('package.json').first();
+    await expect(fileItem).toBeVisible({ timeout: 10_000 });
+    await fileItem.click();
+
+    const highlightToggle = page.locator('[data-testid="ai-highlights-toggle"]');
+    await expect(highlightToggle).toHaveAttribute('title', 'Turn off all highlights', {
+      timeout: 5_000,
+    });
+
+    await highlightToggle.click();
+    await expect(highlightToggle).toHaveAttribute('title', 'Turn on AI highlights', {
+      timeout: 5_000,
+    });
+    await page.screenshot({ path: testInfo.outputPath('highlights-cleared.png'), fullPage: true });
+  });
+});

gitnexus-web/index.html

@@ -4,9 +4,12 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>GitNexus</title>
-    <link rel="preconnect" href="https://fonts.googleapis.com">
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-    <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&family=Outfit:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600&family=Outfit:wght@300;400;500;600;700&display=swap"
+      rel="stylesheet"
+    />
   </head>
   <body>
     <div id="root"></div>

gitnexus-web/package.json

@@ -2,15 +2,23 @@
   "name": "gitnexus",
   "private": true,
   "version": "0.0.0",
+  "engines": {
+    "node": ">=20.0.0"
+  },
   "type": "module",
   "scripts": {
     "dev": "vite",
     "build": "tsc -b && vite build",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:e2e": "playwright test",
+    "test:e2e:ui": "playwright test --ui",
+    "test:e2e:report": "playwright show-report"
   },
   "dependencies": {
-    "@huggingface/transformers": "^3.0.0",
-    "@isomorphic-git/lightning-fs": "^4.6.2",
+    "gitnexus-shared": "file:../gitnexus-shared",
     "@langchain/anthropic": "^1.3.10",
     "@langchain/core": "^1.1.15",
     "@langchain/google-genai": "^2.1.10",
@@ -20,25 +28,20 @@
     "@sigma/edge-curve": "^3.1.0",
     "@tailwindcss/vite": "^4.1.18",
     "axios": "^1.13.2",
-    "buffer": "^6.0.3",
-    "comlink": "^4.4.2",
     "d3": "^7.9.0",
+    "dompurify": "^3.3.3",
     "graphology": "^0.26.0",
     "graphology-indices": "^0.17.0",
-    "graphology-utils": "^2.3.0",
-    "mnemonist": "^0.39.0",
-    "pandemonium": "^2.4.0",
     "graphology-layout-force": "^0.2.4",
     "graphology-layout-forceatlas2": "^0.10.1",
     "graphology-layout-noverlap": "^0.4.2",
-    "isomorphic-git": "^1.36.1",
-    "jszip": "^3.10.1",
-    "@ladybugdb/wasm-core": "^0.15.1",
+    "graphology-utils": "^2.3.0",
     "langchain": "^1.2.10",
     "lru-cache": "^11.2.4",
     "lucide-react": "^0.562.0",
     "mermaid": "^11.12.2",
-    "minisearch": "^7.2.0",
+    "mnemonist": "^0.39.0",
+    "pandemonium": "^2.4.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "react-markdown": "^10.1.0",
@@ -48,23 +51,27 @@
     "sigma": "^3.0.2",
     "tailwindcss": "^4.1.18",
     "uuid": "^13.0.0",
-    "vite-plugin-top-level-await": "^1.6.0",
-    "vite-plugin-wasm": "^3.5.0",
-    "web-tree-sitter": "^0.20.8",
     "zod": "^3.25.76"
   },
   "devDependencies": {
     "@babel/types": "^7.28.5",
-    "@types/jszip": "^3.4.0",
+    "@playwright/test": "^1.58.2",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/dompurify": "^3.0.5",
     "@types/node": "^24.10.1",
     "@types/react": "^18.3.5",
     "@types/react-dom": "^18.3.0",
     "@types/react-syntax-highlighter": "^15.5.13",
     "@vercel/node": "^5.5.16",
     "@vitejs/plugin-react": "^5.1.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "jsdom": "^29.0.0",
     "tree-sitter-wasms": "^0.1.13",
     "typescript": "^5.4.5",
     "vite": "^5.2.0",
-    "vite-plugin-static-copy": "^3.1.4"
+    "vitest": "^3.2.4",
+    "wait-on": "^8.0.5"
   }
 }