@pmaddire/gcie 0.1.8 → 0.1.10

package/GCIE_USAGE.md

@@ -38,8 +38,13 @@ gcie.cmd adaptive-profile . --clear
 ```
 
 Post-init adaptation pipeline:
+- run from the target repo root (cd <repo> first); use . as scope
+- adaptation now bootstraps per-family method defaults before accuracy rounds (plain/plain-gapfill/plain-rescue/slices)
+- adaptation case generation is mixed by design (single-file, same-layer pairs, cross-subtree pairs, and some 3-file chains on larger runs)
 ```powershell
 gcie.cmd adapt . --benchmark-size 10 --efficiency-iterations 5 --clear-profile
+# mixed-layer repos: use wider calibration
+gcie.cmd adapt . --benchmark-size 25 --efficiency-iterations 5 --clear-profile
 ```
 
 One-shot setup + adaptation:
@@ -148,7 +153,7 @@ When retrieval is weak, apply in this exact order:
 1. Query upgrade: add explicit files, symbols, caller/entry anchor
 2. Scope correction: subtree vs root
 3. One profile/budget escalation
-4. Targeted gap-fill for only missing must-have file(s)
+4. Targeted gap-fill for only missing must-have file(s), preferring direct file-path scope first
 5. Multi-hop decomposition only if still incomplete
 
 Stop condition:
@@ -189,6 +194,29 @@ gcie.cmd index .
 - Proceed to calibration only after coverage is reachable with stable behavior.
 - If not reachable, keep safer fallback mode for affected families and continue tracking.
 
+## Calibration Quality Gate (Cross-Repo, Required)
+
+Before accepting adaptation results, verify calibration quality:
+
+1. Family diversity floor:
+- the generated benchmark set should cover at least 3 task families when the repo has multiple top-level subsystems
+- if adaptation output is dominated by only `single_file` and `same_layer_pair`, treat it as underfit
+
+2. Underfit recovery:
+- rerun adaptation with wider calibration
+```powershell
+gcie.cmd adapt . --benchmark-size 25 --efficiency-iterations 5 --clear-profile
+```
+- keep `benchmark-size 10` only for small/single-layer repos or quick smoke checks
+
+3. Accuracy-first acceptance:
+- do not accept a profile below `100%` full-hit if a recoverable path exists
+- run one rescue cycle (query upgrade -> scope correction -> one budget/profile rung -> targeted gap-fill)
+- only then finalize family defaults
+
+4. Cost lock sanity:
+- if selected profile is much more expensive than cheapest (`>40%` token delta), keep status as cost-risk and continue family-level refinement
+- do not freeze expensive global defaults unless they are uniquely required for `100%`
 ## Automatic Post-Trigger Adaptation (Required)
 
 After trigger detection in a repo session:
@@ -338,8 +366,37 @@ After running adaptation:
 Commands:
 ```powershell
 gcie.cmd adapt . --benchmark-size 10 --efficiency-iterations 5 --clear-profile
+# mixed-layer repos: use wider calibration
+gcie.cmd adapt . --benchmark-size 25 --efficiency-iterations 5 --clear-profile
 ```
 ```powershell
 gcie.cmd adapt . --benchmark-size 10 --efficiency-iterations 5
 ```
 
+
+## Remove GCIE From A Repo
+
+To remove GCIE-managed files from the current repo:
+
+```powershell
+gcie.cmd remove .
+```
+
+Options:
+- keep `GCIE_USAGE.md`: `--keep-usage`
+- keep `SETUP_ANY_REPO.md`: `--keep-setup-doc`
+- also remove `.planning` artifacts: `--remove-planning`
+
+Example:
+
+```powershell
+gcie.cmd remove . --remove-planning
+```
+
+
+
+
+
+
+
+

package/cli/app.py

@@ -14,7 +14,7 @@ from .commands.context_slices import adaptive_profile_summary, clear_adaptive_pr
 from .commands.debug import run_debug
 from .commands.index import run_index
 from .commands.query import run_query
-from .commands.setup import run_setup
+from .commands.setup import run_remove, run_setup
 
 app = typer.Typer(help="GraphCode Intelligence Engine CLI")
 
@@ -177,6 +177,21 @@ def setup_cmd(
     typer.echo(json.dumps(result, indent=2))
 
 
+@app.command("remove")
+def remove_cmd(
+    path: str = typer.Argument("."),
+    remove_planning: bool = typer.Option(False, "--remove-planning", help="Also remove .planning artifacts"),
+    keep_usage: bool = typer.Option(False, "--keep-usage", help="Keep GCIE_USAGE.md in place"),
+    keep_setup_doc: bool = typer.Option(False, "--keep-setup-doc", help="Keep SETUP_ANY_REPO.md in place"),
+) -> None:
+    result = run_remove(
+        path,
+        remove_planning=remove_planning,
+        remove_gcie_usage=not keep_usage,
+        remove_setup_doc=not keep_setup_doc,
+    )
+    typer.echo(json.dumps(result, indent=2))
+
 @app.command("cache-clear")
 def cache_clear_cmd(path: str = typer.Argument(".")) -> None:
     result = clear_cache(path)
@@ -197,3 +212,5 @@ def cache_warm_cmd(path: str = typer.Argument(".")) -> None:
 
 if __name__ == "__main__":
     app()
+
+

package/cli/commands/adaptation.py

@@ -1,4 +1,4 @@
-"""Post-initialization adaptation pipeline (accuracy first, then efficiency)."""
+"""Post-initialization adaptation pipeline (accuracy rounds first, then efficiency rounds)."""
 
 from __future__ import annotations
 
@@ -14,7 +14,7 @@ from .index import run_index
 
 try:
     from performance.context_benchmark import BENCHMARK_CASES
-except Exception:  # pragma: no cover - fallback for limited installs
+except Exception:  # pragma: no cover
     BENCHMARK_CASES = ()
 
 
@@ -52,16 +52,60 @@ _IGNORED_DIRS = {
     "build",
     "coverage",
 }
+_METHOD_ORDER = ["plain", "plain_gapfill", "plain_rescue", "slices"]
 
 
 def _query_keywords(text: str) -> list[str]:
-    terms: list[str] = []
-    for token in _WORD_RE.findall(text.lower()):
-        if len(token) < 4:
-            continue
-        terms.append(token)
-    return terms[:8]
+    return [t for t in _WORD_RE.findall(text.lower()) if len(t) >= 4][:8]
+
+
+def _extract_query_cues_for_file(repo_path: Path, rel: str) -> list[str]:
+    path = repo_path / rel
+    try:
+        text = path.read_text(encoding='utf-8', errors='ignore')
+    except Exception:
+        return [Path(rel).stem.lower()]
+
+    body = text[:12000]
+    cues: list[str] = [Path(rel).stem.lower()]
+
+    patterns = [
+        r"^\s*def\s+([A-Za-z_][A-Za-z0-9_]*)",
+        r"^\s*class\s+([A-Za-z_][A-Za-z0-9_]*)",
+        r"^\s*(?:async\s+)?function\s+([A-Za-z_][A-Za-z0-9_]*)",
+        r"^\s*const\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(?:async\s*)?(?:\(|function\b)",
+        r"^\s*export\s+function\s+([A-Za-z_][A-Za-z0-9_]*)",
+    ]
+    for pat in patterns:
+        for name in re.findall(pat, body, flags=re.MULTILINE):
+            token = str(name).lower()
+            if len(token) >= 4:
+                cues.append(token)
+            if len(cues) >= 8:
+                break
+        if len(cues) >= 8:
+            break
 
+    for route in re.findall(r"['\"](/api/[A-Za-z0-9_/{}/-]+)['\"]", body):
+        cues.append(route.lower())
+        if len(cues) >= 10:
+            break
+
+    for key in re.findall(r"\b[A-Z][A-Z0-9_]{3,}\b", body):
+        cues.append(key.lower())
+        if len(cues) >= 12:
+            break
+
+    dedup: list[str] = []
+    seen: set[str] = set()
+    for cue in cues:
+        if cue in seen:
+            continue
+        seen.add(cue)
+        dedup.append(cue)
+        if len(dedup) >= 8:
+            break
+    return dedup
 
 def _node_to_file(node_id: str) -> str | None:
     if node_id.startswith("file:"):
@@ -83,17 +127,33 @@ def _normalize_scoped_path(plan_path: str, rel_path: str) -> str:
     return f"{base}/{normalized}"
 
 
-def _family_path(expected_files: tuple[str, ...]) -> str:
-    if not expected_files:
-        return "."
-    heads = {Path(p).parts[0] for p in expected_files if Path(p).parts}
-    if len(heads) == 1:
-        return next(iter(heads))
-    return "."
-
+def _family_path(expected_files: tuple[str, ...]) -> str:
+    if not expected_files:
+        return "."
+    parent_parts: list[tuple[str, ...]] = []
+    for rel in expected_files:
+        parent = Path(rel).parent
+        if str(parent) in {"", "."}:
+            parent_parts.append(tuple())
+        else:
+            parent_parts.append(tuple(parent.parts))
+
+    common: list[str] = []
+    if parent_parts:
+        shortest = min(len(parts) for parts in parent_parts)
+        for idx in range(shortest):
+            token = parent_parts[0][idx]
+            if all(parts[idx] == token for parts in parent_parts):
+                common.append(token)
+            else:
+                break
+    if common:
+        return Path(*common).as_posix()
+
+    heads = {Path(p).parts[0] for p in expected_files if Path(p).parts}
+    return next(iter(heads)) if len(heads) == 1 else "."
 
 def _safe_scope(path: str) -> str:
-    """Return a valid retrieval scope for the current repo."""
     if not path or path in {".", "./"}:
         return "."
     candidate = Path(path)
@@ -102,34 +162,81 @@ def _safe_scope(path: str) -> str:
     return "."
 
 
-def _plan_query(case) -> tuple[str, str, int | None]:
-    path = _family_path(case.expected_files)
-    if getattr(case, "name", "") == "cli_context_command":
-        path = "."
-        query = "cli/commands/context.py llm_context/context_builder.py build_context token_budget mandatory_node_ids snippet_selector"
-        return path, query, 950
-    keywords = " ".join(_query_keywords(case.query)[:4])
-    file_terms = " ".join(case.expected_files)
-    query = f"{file_terms} {keywords}".strip()
-    budget = 1000 if len(case.expected_files) >= 2 else None
-    if getattr(case, "name", "") in {
-        "repository_scanner_filters",
-        "knowledge_index_query_api",
-        "execution_trace_graph",
-        "parser_fallbacks",
-    }:
-        budget = 800
+def _plan_query(case) -> tuple[str, str, int | None]:
+    path = _family_path(case.expected_files)
+    if getattr(case, "name", "") == "cli_context_command":
+        return ".", "cli/commands/context.py llm_context/context_builder.py build_context token_budget mandatory_node_ids snippet_selector", 950
+
+    repo_path = Path('.').resolve()
+    cue_terms: list[str] = []
+    for rel in case.expected_files:
+        cue_terms.extend(_extract_query_cues_for_file(repo_path, rel)[:3])
+    cue_terms.extend(_query_keywords(case.query)[:4])
+
+    dedup: list[str] = []
+    seen: set[str] = set()
+    for token in [*case.expected_files, *cue_terms]:
+        key = token.lower()
+        if key in seen:
+            continue
+        seen.add(key)
+        dedup.append(token)
+        if len(dedup) >= 14:
+            break
+    query = " ".join(dedup).strip()
+
+    expected_count = len(case.expected_files)
+    if expected_count >= 3:
+        budget = 1100
+    elif expected_count == 2:
+        budget = 950
+    else:
+        budget = 850
+
+    if getattr(case, "name", "") in {"repository_scanner_filters", "knowledge_index_query_api", "execution_trace_graph", "parser_fallbacks"}:
+        budget = 800
     return path, query, budget
 
+def _case_family(case) -> str:
+    _, planned_query, _ = _plan_query(case)
+    return _classify_query_family(planned_query)
+
+
+def _build_gapfill_query(case, missing_rel: str) -> str:
+    anchors = [rel for rel in case.expected_files if rel != missing_rel][:2]
+    repo_path = Path('.').resolve()
+
+    tokens: list[str] = [missing_rel]
+    tokens.extend(anchors)
+
+    cue_files = [missing_rel]
+    cue_files.extend(anchors)
+    for rel in cue_files:
+        tokens.extend(_extract_query_cues_for_file(repo_path, rel)[:4])
+
+    tokens.extend(_query_keywords(case.query)[:4])
 
-def _evaluate_plain_case(case, *, allow_gapfill: bool = True) -> CaseResult:
+    dedup: list[str] = []
+    seen: set[str] = set()
+    for tok in tokens:
+        key = tok.lower()
+        if key in seen:
+            continue
+        seen.add(key)
+        dedup.append(tok)
+        if len(dedup) >= 14:
+            break
+
+    return " ".join(dedup)
+
+def _evaluate_plain_case(case, *, allow_gapfill: bool = True, aggressive_gapfill: bool = False) -> CaseResult:
     path, query, budget = _plan_query(case)
     path = _safe_scope(path)
     payload = run_context(path, query, budget=budget, intent=case.intent)
     files = {
-        _normalize_scoped_path(path, rel_path)
-        for rel_path in (_node_to_file(item.get("node_id", "")) for item in payload.get("snippets", []))
-        if rel_path
+        _normalize_scoped_path(path, rel)
+        for rel in (_node_to_file(item.get("node_id", "")) for item in payload.get("snippets", []))
+        if rel
     }
     expected = tuple(case.expected_files)
     missing = [rel for rel in expected if rel not in files]
@@ -139,19 +246,39 @@ def _evaluate_plain_case(case, *, allow_gapfill: bool = True) -> CaseResult:
     if allow_gapfill and missing:
         mode = "plain_context_workflow_gapfill"
         for rel in list(missing):
-            scope = _safe_scope(_family_path((rel,)))
-            gap_keywords = " ".join(_query_keywords(case.query)[:4])
-            gap_query = f"{rel} {gap_keywords}".strip()
-            gap_budget = 500 if rel.endswith("/main.py") or rel == "main.py" else 900
-            gap_payload = run_context(scope, gap_query, budget=gap_budget, intent=case.intent)
-            tokens += int(gap_payload.get("tokens", 0) or 0)
-            gap_files = {
-                _normalize_scoped_path(scope, rel_path)
-                for rel_path in (_node_to_file(item.get("node_id", "")) for item in gap_payload.get("snippets", []))
-                if rel_path
-            }
-            files.update(gap_files)
-            missing = [m for m in expected if m not in files]
+            gap_query = _build_gapfill_query(case, rel)
+
+            # Prefer direct file-targeted recovery when possible to avoid expensive broad rescues.
+            direct_scope = rel if (Path(rel).exists() and Path(rel).is_file()) else None
+            base_scope = _safe_scope(_family_path((rel,)))
+            scopes: list[str] = []
+            if direct_scope:
+                scopes.append(direct_scope)
+            if base_scope not in scopes:
+                scopes.append(base_scope)
+
+            budgets = [500 if rel.endswith('/main.py') or rel == 'main.py' else 900]
+            if len(scopes) > 1:
+                budgets.append(budgets[0])
+
+            if aggressive_gapfill:
+                if '.' not in scopes:
+                    scopes.append('.')
+                    budgets.append(max(budgets[0], 1200))
+                mode = "plain_context_workflow_gapfill_rescue"
+
+            for scope, gap_budget in zip(scopes, budgets):
+                gap_payload = run_context(scope, gap_query, budget=gap_budget, intent=case.intent)
+                tokens += int(gap_payload.get("tokens", 0) or 0)
+                gap_files = {
+                    _normalize_scoped_path(scope, rel2)
+                    for rel2 in (_node_to_file(item.get("node_id", "")) for item in gap_payload.get("snippets", []))
+                    if rel2
+                }
+                files.update(gap_files)
+                missing = [m for m in expected if m not in files]
+                if not missing:
+                    break
             if not missing:
                 break
 
@@ -171,9 +298,9 @@ def _evaluate_plain_case(case, *, allow_gapfill: bool = True) -> CaseResult:
 
 def _evaluate_slices_case(case) -> CaseResult:
     payload = run_context_slices(
-        repo=".",
+        repo='.',
         query=case.query,
-        profile="low",
+        profile='low',
         stage_a_budget=300,
         stage_b_budget=600,
         max_total=800,
@@ -184,19 +311,15 @@ def _evaluate_slices_case(case) -> CaseResult:
     )
     mode = "slices_low"
     tokens = int(payload.get("token_estimate", payload.get("tokens", 0)) or 0)
-    files = {
-        _node_to_file(item.get("node_id", ""))
-        for item in payload.get("snippets", [])
-    }
-    files = {f for f in files if f}
+    files = {f for f in (_node_to_file(item.get("node_id", "")) for item in payload.get("snippets", [])) if f}
     expected = tuple(case.expected_files)
     missing = [rel for rel in expected if rel not in files]
     if missing:
         mode = "slices_recall"
         recall_payload = run_context_slices(
-            repo=".",
+            repo='.',
             query=case.query,
-            profile="recall",
+            profile='recall',
             stage_a_budget=400,
             stage_b_budget=800,
             max_total=1200,
@@ -206,21 +329,15 @@ def _evaluate_slices_case(case) -> CaseResult:
             include_tests=False,
         )
         tokens += int(recall_payload.get("token_estimate", recall_payload.get("tokens", 0)) or 0)
-        files.update(
-            {
-                f
-                for f in (_node_to_file(item.get("node_id", "")) for item in recall_payload.get("snippets", []))
-                if f
-            }
-        )
+        files.update({f for f in (_node_to_file(item.get("node_id", "")) for item in recall_payload.get("snippets", [])) if f})
         missing = [rel for rel in expected if rel not in files]
     if missing:
         mode = "slices_recall_pin"
         for rel in list(missing):
             pin_payload = run_context_slices(
-                repo=".",
+                repo='.',
                 query=case.query,
-                profile="recall",
+                profile='recall',
                 stage_a_budget=400,
                 stage_b_budget=800,
                 max_total=1200,
@@ -230,18 +347,13 @@ def _evaluate_slices_case(case) -> CaseResult:
                 include_tests=False,
             )
             tokens += int(pin_payload.get("token_estimate", pin_payload.get("tokens", 0)) or 0)
-            files.update(
-                {
-                    f
-                    for f in (_node_to_file(item.get("node_id", "")) for item in pin_payload.get("snippets", []))
-                    if f
-                }
-            )
+            files.update({f for f in (_node_to_file(item.get("node_id", "")) for item in pin_payload.get("snippets", [])) if f})
             missing = [m for m in expected if m not in files]
             if not missing:
                 break
+
     expected_hits = len(expected) - len(missing)
-    family = _classify_query_family(case.query)
+    family = _case_family(case)
     return CaseResult(
         name=case.name,
         family=family,
@@ -254,6 +366,16 @@ def _evaluate_slices_case(case) -> CaseResult:
     )
 
 
+def _evaluate_case_with_method(case, method: str) -> CaseResult:
+    if method == "plain":
+        return _evaluate_plain_case(case, allow_gapfill=False)
+    if method == "plain_gapfill":
+        return _evaluate_plain_case(case, allow_gapfill=True, aggressive_gapfill=False)
+    if method == "plain_rescue":
+        return _evaluate_plain_case(case, allow_gapfill=True, aggressive_gapfill=True)
+    return _evaluate_slices_case(case)
+
+
 def _summarize(label: str, rows: list[CaseResult]) -> dict:
     case_count = len(rows)
     pass_count = sum(1 for row in rows if row.context_complete)
@@ -275,7 +397,7 @@ def _summarize(label: str, rows: list[CaseResult]) -> dict:
 
 def _collect_source_files(repo_path: Path) -> list[str]:
     files: list[str] = []
-    for path in repo_path.rglob("*"):
+    for path in repo_path.rglob('*'):
         if not path.is_file():
             continue
         rel = path.relative_to(repo_path)
@@ -287,29 +409,6 @@ def _collect_source_files(repo_path: Path) -> list[str]:
     return sorted(files)
 
 
-def _static_cases_for_repo(repo_path: Path) -> list[AdaptCase]:
-    out: list[AdaptCase] = []
-    for case in list(BENCHMARK_CASES):
-        expected = tuple(case.expected_files)
-        if not expected:
-            continue
-        if not all((repo_path / rel).exists() for rel in expected):
-            continue
-        baseline = tuple(rel for rel in case.baseline_files if (repo_path / rel).exists())
-        if not baseline:
-            baseline = expected
-        out.append(
-            AdaptCase(
-                name=case.name,
-                query=case.query,
-                intent=case.intent,
-                baseline_files=baseline,
-                expected_files=expected,
-            )
-        )
-    return out
-
-
 def _generated_cases_for_repo(repo_path: Path, needed: int) -> list[AdaptCase]:
     files = _collect_source_files(repo_path)
     if not files:
@@ -317,15 +416,20 @@ def _generated_cases_for_repo(repo_path: Path, needed: int) -> list[AdaptCase]:
 
     by_dir: dict[str, list[str]] = {}
     for rel in files:
-        parent = str(Path(rel).parent).replace("\\", "/")
+        parent = str(Path(rel).parent).replace('\\', '/')
         by_dir.setdefault(parent, []).append(rel)
 
     rows: list[AdaptCase] = []
     seen_names: set[str] = set()
+    seen_expected: set[tuple[str, ...]] = set()
+    cue_cache: dict[str, list[str]] = {}
 
-    def add_case(name: str, expected: tuple[str, ...], intent: str = "explore") -> None:
+    def add_case(name: str, expected: tuple[str, ...], intent: str = 'explore') -> None:
         if len(rows) >= needed:
             return
+        expected_key = tuple(sorted(expected))
+        if expected_key in seen_expected:
+            return
         safe_name = re.sub(r"[^a-zA-Z0-9_]+", "_", name).strip("_").lower() or "case"
         if safe_name in seen_names:
             idx = 2
@@ -333,93 +437,224 @@ def _generated_cases_for_repo(repo_path: Path, needed: int) -> list[AdaptCase]:
                 idx += 1
             safe_name = f"{safe_name}_{idx}"
         seen_names.add(safe_name)
-        symbols = []
+        seen_expected.add(expected_key)
+        symbols: list[str] = []
         for rel in expected:
-            stem = Path(rel).stem.lower()
-            symbols.extend([stem, "flow", "wiring"])
-        query = f"{' '.join(expected)} {' '.join(symbols[:6])}".strip()
-        rows.append(
-            AdaptCase(
-                name=safe_name,
-                query=query,
-                intent=intent,
-                baseline_files=expected,
-                expected_files=expected,
-            )
-        )
-
-    # Single-file probes.
+            cues = cue_cache.get(rel)
+            if cues is None:
+                cues = _extract_query_cues_for_file(repo_path, rel)
+                cue_cache[rel] = cues
+            symbols.extend(cues)
+        if not symbols:
+            symbols = [Path(rel).stem.lower() for rel in expected]
+        query = f"{' '.join(expected)} {' '.join(symbols[:8])}".strip()
+        rows.append(AdaptCase(name=safe_name, query=query, intent=intent, baseline_files=expected, expected_files=expected))
+
+    # Build a diversified sample so adaptation can learn in mixed-layer repos.
+    single_target = max(1, needed // 3)
+    same_dir_target = max(1, needed // 3)
+    cross_dir_target = max(1, needed - single_target - same_dir_target)
+
+    # 1) singles
     for rel in files:
-        add_case(f"single_{Path(rel).stem}", (rel,), intent="explore")
-        if len(rows) >= max(needed // 2, 1):
+        add_case(f"single_{Path(rel).stem}", (rel,), intent='explore')
+        if len(rows) >= single_target:
             break
 
-    # Same-directory pairs.
-    for parent, group in sorted(by_dir.items(), key=lambda item: item[0]):
+    # 2) same-dir adjacent pairs
+    same_pairs_added = 0
+    for parent, group in sorted(by_dir.items(), key=lambda x: x[0]):
         if len(group) < 2:
             continue
+        label = "root" if parent in {'.', ''} else parent
         group = sorted(group)
         for idx in range(len(group) - 1):
-            add_case(f"pair_{parent}_{idx}", (group[idx], group[idx + 1]), intent="explore")
+            add_case(f"pair_{label}_{idx}", (group[idx], group[idx + 1]), intent='explore')
             if len(rows) >= needed:
                 return rows[:needed]
+            same_pairs_added += 1
+            if same_pairs_added >= same_dir_target:
+                break
+        if same_pairs_added >= same_dir_target:
+            break
 
-    # Cross-directory pairs if still needed.
+    # 3) cross-dir pairs (top-level representatives)
     tops: dict[str, str] = {}
     for rel in files:
         top = Path(rel).parts[0] if Path(rel).parts else rel
         tops.setdefault(top, rel)
-    top_files = list(tops.values())
-    for idx in range(len(top_files) - 1):
-        add_case(f"cross_{idx}", (top_files[idx], top_files[idx + 1]), intent="explore")
+    top_items = sorted(tops.items(), key=lambda item: item[0])
+    cross_added = 0
+    for idx in range(len(top_items) - 1):
+        left = top_items[idx][1]
+        right = top_items[idx + 1][1]
+        add_case(f"cross_{top_items[idx][0]}_{top_items[idx + 1][0]}", (left, right), intent='explore')
         if len(rows) >= needed:
+            return rows[:needed]
+        cross_added += 1
+        if cross_added >= cross_dir_target:
             break
 
+    # 4) include some 3-file chains for multi-hop calibration when dataset is larger.
+    if needed >= 12 and len(rows) < needed:
+        chain_budget = max(1, needed // 6)
+        chains_added = 0
+        reps = [item[1] for item in top_items]
+        for idx in range(len(reps) - 2):
+            add_case(
+                f"chain_{idx}",
+                (reps[idx], reps[idx + 1], reps[idx + 2]),
+                intent='refactor',
+            )
+            if len(rows) >= needed:
+                return rows[:needed]
+            chains_added += 1
+            if chains_added >= chain_budget:
+                break
+
+    # 5) fill remainder with additional nearby pairs
+    if len(rows) < needed:
+        for idx in range(len(files) - 1):
+            add_case(f"fill_{idx}", (files[idx], files[idx + 1]), intent='explore')
+            if len(rows) >= needed:
+                break
+
     return rows[:needed]
 
 
 def _select_adaptation_cases(repo_path: Path, benchmark_size: int) -> tuple[list[AdaptCase], str]:
-    """Select adaptation cases generated entirely from the target repo."""
     benchmark_size = max(1, int(benchmark_size))
     generated = _generated_cases_for_repo(repo_path, benchmark_size)
     if generated:
-        return generated[:benchmark_size], "generated_repo_local"
-    return [], "none_available"
-
-
-def _write_back(repo_path: Path, best: dict, case_source: str, pipeline_status: str, cost_analysis: dict) -> None:
-    cfg_path = repo_path / ".gcie" / "context_config.json"
+        return generated[:benchmark_size], 'generated_repo_local'
+    return [], 'none_available'
+
+
+def _next_method(method: str) -> str:
+    try:
+        idx = _METHOD_ORDER.index(method)
+    except ValueError:
+        return _METHOD_ORDER[0]
+    return _METHOD_ORDER[min(idx + 1, len(_METHOD_ORDER) - 1)]
+
+
+def _cheaper_method(method: str) -> str | None:
+    try:
+        idx = _METHOD_ORDER.index(method)
+    except ValueError:
+        return None
+    if idx <= 0:
+        return None
+    return _METHOD_ORDER[idx - 1]
+
+
+def _run_family_policy(cases: list[AdaptCase], family_policy: dict[str, str]) -> tuple[list[CaseResult], dict, dict[str, dict]]:
+    rows: list[CaseResult] = []
+    for case in cases:
+        family = _case_family(case)
+        method = family_policy.get(family, 'plain')
+        rows.append(_evaluate_case_with_method(case, method))
+    summary = _summarize('policy_run', rows)
+
+    by_family: dict[str, dict] = {}
+    for row in rows:
+        entry = by_family.setdefault(row.family, {'cases': 0, 'passes': 0, 'tokens': 0})
+        entry['cases'] += 1
+        entry['passes'] += 1 if row.context_complete else 0
+        entry['tokens'] += row.tokens
+    for fam, entry in by_family.items():
+        entry['pass_rate'] = round(entry['passes'] / max(1, entry['cases']), 3)
+        entry['tokens_per_case'] = round(entry['tokens'] / max(1, entry['cases']), 1)
+
+    return rows, summary, by_family
+
+
+def _select_best_summary(summaries: list[dict]) -> dict:
+    full_hit = [s for s in summaries if s.get("full_hit_rate_pct", 0.0) >= 100.0]
+    if full_hit:
+        return min(full_hit, key=lambda s: (s.get("tokens_per_expected_hit") or 10**9, s.get("tokens_per_query", 10**9)))
+    return max(
+        summaries,
+        key=lambda s: (s.get("target_hit_rate_pct", 0.0), -s.get("tokens_per_query", 10**9)),
+    )
+
+
+def _bootstrap_family_policy(cases: list[AdaptCase], families: list[str]) -> tuple[dict[str, str], list[dict]]:
+    policy: dict[str, str] = {}
+    diagnostics: list[dict] = []
+    for fam in families:
+        fam_cases = [case for case in cases if _case_family(case) == fam]
+        if not fam_cases:
+            policy[fam] = "plain"
+            continue
+
+        method_summaries: list[dict] = []
+        for method in _METHOD_ORDER:
+            rows = [_evaluate_case_with_method(case, method) for case in fam_cases]
+            summary = _summarize(f"bootstrap_{fam}_{method}", rows)
+            summary["method"] = method
+            summary["family"] = fam
+            method_summaries.append(summary)
+
+        best = _select_best_summary(method_summaries)
+        selected_method = str(best.get("method", "plain"))
+        policy[fam] = selected_method
+        diagnostics.append(
+            {
+                "family": fam,
+                "selected_method": selected_method,
+                "selected_summary": best,
+                "candidates": method_summaries,
+            }
+        )
+    return policy, diagnostics
+def _write_back(repo_path: Path, best: dict, case_source: str, pipeline_status: str, cost_analysis: dict, family_policy: dict[str, str]) -> None:
+    cfg_path = repo_path / '.gcie' / 'context_config.json'
     if cfg_path.exists():
         try:
-            cfg = json.loads(cfg_path.read_text(encoding="utf-8"))
+            cfg = json.loads(cfg_path.read_text(encoding='utf-8'))
             if not isinstance(cfg, dict):
                 cfg = {}
         except Exception:
             cfg = {}
     else:
         cfg = {}
-    cfg["adaptation_pipeline"] = {
-        "status": pipeline_status,
-        "best_label": best.get("label"),
-        "full_hit_rate_pct": best.get("full_hit_rate_pct"),
-        "tokens_per_query": best.get("tokens_per_query"),
-        "case_source": case_source,
-        "cost_analysis": cost_analysis,
-        "updated_at": datetime.now(timezone.utc).isoformat(),
+
+    cfg['adaptation_pipeline'] = {
+        'status': pipeline_status,
+        'best_label': best.get('label'),
+        'full_hit_rate_pct': best.get('full_hit_rate_pct'),
+        'tokens_per_query': best.get('tokens_per_query'),
+        'case_source': case_source,
+        'cost_analysis': cost_analysis,
+        'family_policy': family_policy,
+        'updated_at': datetime.now(timezone.utc).isoformat(),
     }
     cfg_path.parent.mkdir(parents=True, exist_ok=True)
-    cfg_path.write_text(json.dumps(cfg, indent=2), encoding="utf-8")
-
+    cfg_path.write_text(json.dumps(cfg, indent=2), encoding='utf-8')
+
+def _select_best_full_hit(candidates: list[dict]) -> dict | None:
+    full_hit = [c for c in candidates if c.get('full_hit_rate_pct', 0.0) >= 100.0]
+    if not full_hit:
+        return None
+    return min(
+        full_hit,
+        key=lambda item: (item.get('tokens_per_expected_hit') or 10**9, item.get('tokens_per_query', 10**9)),
+    )
 
 def run_post_init_adaptation(
-    repo: str = ".",
+    repo: str = '.',
     *,
     benchmark_size: int = 10,
     efficiency_iterations: int = 5,
     clear_profile: bool = False,
 ) -> dict:
-    """Run accuracy-lock then efficiency adaptation protocol after setup/index."""
     repo_path = Path(repo).resolve()
+
+    # Ensure all relative retrieval/evaluation calls execute in the target repo.
+    import os
+
+    os.chdir(repo_path)
     run_index(repo_path.as_posix())
 
     if clear_profile:
@@ -430,80 +665,180 @@ def run_post_init_adaptation(
     cases, case_source = _select_adaptation_cases(repo_path, benchmark_size)
     if not cases:
         return {
-            "status": "no_benchmark_cases",
-            "repo": repo_path.as_posix(),
-            "case_source": case_source,
-            "message": "No repo-usable adaptation cases available.",
+            'status': 'no_benchmark_cases',
+            'repo': repo_path.as_posix(),
+            'case_source': case_source,
+            'message': 'No repo-usable adaptation cases available.',
         }
 
-    slices_rows = [_evaluate_slices_case(case) for case in cases]
-    plain_rows = [_evaluate_plain_case(case, allow_gapfill=False) for case in cases]
-    plain_gap_rows = [_evaluate_plain_case(case, allow_gapfill=True) for case in cases]
+    families = sorted({_case_family(case) for case in cases})
+    family_policy, bootstrap_diagnostics = _bootstrap_family_policy(cases, families)
+
+    # Accuracy rounds: promote methods per failing family until lock.
+    accuracy_rounds_max = 5
+    accuracy_rounds: list[dict] = []
+    lock_streak = 0
+
+    for rnd in range(1, accuracy_rounds_max + 1):
+        rows, summary, by_family = _run_family_policy(cases, family_policy)
+        round_payload = {
+            'round': rnd,
+            'family_policy': dict(family_policy),
+            'summary': summary,
+            'family_metrics': by_family,
+        }
+        accuracy_rounds.append(round_payload)
 
-    slices_summary = _summarize("slices_accuracy_stage", slices_rows)
-    plain_summary = _summarize("plain_accuracy_stage", plain_rows)
-    plain_gap_summary = _summarize("plain_gapfill_accuracy_stage", plain_gap_rows)
+        if summary['full_hit_rate_pct'] >= 100.0:
+            lock_streak += 1
+            if lock_streak >= 2:
+                break
+            continue
 
-    candidates = [slices_summary, plain_summary, plain_gap_summary]
-    full_hit = [candidate for candidate in candidates if candidate["full_hit_rate_pct"] >= 100.0]
-    if full_hit:
-        best = min(full_hit, key=lambda item: (item["tokens_per_expected_hit"] or 10**9, item["tokens_per_query"]))
+        lock_streak = 0
+        for fam, metrics in by_family.items():
+            if metrics.get('pass_rate', 0.0) < 1.0:
+                family_policy[fam] = _next_method(family_policy.get(fam, 'plain'))
+
+    # Select best accuracy-locked round if available.
+    locked_rounds = [r for r in accuracy_rounds if r['summary']['full_hit_rate_pct'] >= 100.0]
+    if locked_rounds:
+        selected_accuracy_round = min(
+            locked_rounds,
+            key=lambda r: (r['summary'].get('tokens_per_expected_hit') or 10**9, r['summary'].get('tokens_per_query', 10**9)),
+        )
     else:
-        best = max(candidates, key=lambda item: item["target_hit_rate_pct"])
+        selected_accuracy_round = max(
+            accuracy_rounds,
+            key=lambda r: (r['summary'].get('target_hit_rate_pct', 0.0), -r['summary'].get('tokens_per_query', 10**9)),
+        )
+
+    family_policy = dict(selected_accuracy_round['family_policy'])
+    rows, current_summary, by_family = _run_family_policy(cases, family_policy)
 
+    # Efficiency rounds: attempt family-level cheaper method under hard 100% gate.
     efficiency_trials: list[dict] = []
-    active = best
     for idx in range(max(0, int(efficiency_iterations))):
-        if active["label"] != "plain_gapfill_accuracy_stage":
+        improved = False
+        for fam in families:
+            cheaper = _cheaper_method(family_policy.get(fam, 'plain'))
+            if not cheaper:
+                continue
+            trial_policy = dict(family_policy)
+            trial_policy[fam] = cheaper
+            _, trial_summary, trial_by_family = _run_family_policy(cases, trial_policy)
+            trial_payload = {
+                'iteration': idx + 1,
+                'family': fam,
+                'trial_policy': trial_policy,
+                'summary': trial_summary,
+            }
+            efficiency_trials.append(trial_payload)
+
+            if (
+                trial_summary.get('full_hit_rate_pct', 0.0) >= 100.0
+                and trial_summary.get('tokens_per_query', 10**9) < current_summary.get('tokens_per_query', 10**9)
+            ):
+                family_policy = trial_policy
+                current_summary = trial_summary
+                by_family = trial_by_family
+                improved = True
+        if not improved:
             break
-        trial_rows = [_evaluate_plain_case(case, allow_gapfill=True) for case in cases]
-        trial = _summarize(f"plain_gapfill_eff_trial_{idx + 1}", trial_rows)
-        efficiency_trials.append(trial)
-        if trial["full_hit_rate_pct"] >= active["full_hit_rate_pct"] and trial["tokens_per_query"] < active["tokens_per_query"]:
-            active = trial
 
-    cheapest = min(candidates, key=lambda item: (item["tokens_per_expected_hit"] or 10**9, item["tokens_per_query"]))
-    token_delta = int(active["total_tokens"] - cheapest["total_tokens"])
-    pct_delta = round((token_delta / max(1, int(cheapest["total_tokens"]))) * 100, 1)
+    # Global candidate snapshots for transparency.
+    slices_rows = [_evaluate_case_with_method(case, 'slices') for case in cases]
+    plain_rows = [_evaluate_case_with_method(case, 'plain') for case in cases]
+    plain_gap_rows = [_evaluate_case_with_method(case, 'plain_gapfill') for case in cases]
+    plain_rescue_rows = [_evaluate_case_with_method(case, 'plain_rescue') for case in cases]
+    slices_summary = _summarize('slices_accuracy_stage', slices_rows)
+    plain_summary = _summarize('plain_accuracy_stage', plain_rows)
+    plain_gap_summary = _summarize('plain_gapfill_accuracy_stage', plain_gap_rows)
+    plain_rescue_summary = _summarize('plain_rescue_accuracy_stage', plain_rescue_rows)
+    candidates = [slices_summary, plain_summary, plain_gap_summary, plain_rescue_summary]
+
+    active = {
+        'label': 'family_policy_selected',
+        **current_summary,
+    }
+
+    # Hard accuracy fallback: never finalize below 100% when any known candidate reaches 100%.
+    all_full_hit_candidates = list(candidates)
+    all_full_hit_candidates.extend(r['summary'] for r in accuracy_rounds)
+    all_full_hit_candidates.append(current_summary)
+    best_full_hit = _select_best_full_hit(all_full_hit_candidates)
+    if active.get('full_hit_rate_pct', 0.0) < 100.0 and best_full_hit is not None:
+        active = dict(best_full_hit)
 
-    pipeline_status = "ok"
+    cheapest = min(candidates, key=lambda item: (item.get('tokens_per_expected_hit') or 10**9, item.get('tokens_per_query', 10**9)))
+    token_delta = int(active['total_tokens'] - cheapest['total_tokens'])
+    pct_delta = round((token_delta / max(1, int(cheapest['total_tokens']))) * 100, 1)
+
+    pipeline_status = 'ok'
     if (
-        active.get("full_hit_rate_pct", 0.0) >= 100.0
-        and active.get("label") != cheapest.get("label")
+        active.get('full_hit_rate_pct', 0.0) >= 100.0
+        and active.get('tokens_per_query', 10**9) > cheapest.get('tokens_per_query', 10**9)
         and pct_delta > 40.0
     ):
-        pipeline_status = "accuracy_locked_but_cost_risky"
+        pipeline_status = 'accuracy_locked_but_cost_risky'
 
     cost_analysis = {
-        "cheapest_label": cheapest.get("label"),
-        "selected_label": active.get("label"),
-        "selected_vs_cheapest_token_delta": token_delta,
-        "selected_vs_cheapest_pct_delta": pct_delta,
-        "risk_threshold_pct": 40.0,
-        "cost_risky": pipeline_status == "accuracy_locked_but_cost_risky",
+        'cheapest_label': cheapest.get('label'),
+        'selected_label': active.get('label'),
+        'selected_vs_cheapest_token_delta': token_delta,
+        'selected_vs_cheapest_pct_delta': pct_delta,
+        'risk_threshold_pct': 40.0,
+        'cost_risky': pipeline_status == 'accuracy_locked_but_cost_risky',
     }
 
-    _write_back(repo_path, active, case_source, pipeline_status, cost_analysis)
+    _write_back(repo_path, active, case_source, pipeline_status, cost_analysis, family_policy)
 
     report = {
-        "status": pipeline_status,
-        "repo": repo_path.as_posix(),
-        "benchmark_size": len(cases),
-        "requested_benchmark_size": int(benchmark_size),
-        "efficiency_iterations": int(efficiency_iterations),
-        "case_source": case_source,
-        "cost_analysis": cost_analysis,
-        "stages": {
-            "accuracy_candidates": [slices_summary, plain_summary, plain_gap_summary],
-            "selected_after_accuracy": best,
-            "efficiency_trials": efficiency_trials,
-            "selected_final": active,
+        'status': pipeline_status,
+        'repo': repo_path.as_posix(),
+        'benchmark_size': len(cases),
+        'requested_benchmark_size': int(benchmark_size),
+        'efficiency_iterations': int(efficiency_iterations),
+        'case_source': case_source,
+        'family_policy': family_policy,
+        'cost_analysis': cost_analysis,
+        'phases': {
+            'bootstrap': bootstrap_diagnostics,
+            'accuracy_rounds': accuracy_rounds,
+            'selected_accuracy_round': selected_accuracy_round,
+            'efficiency_trials': efficiency_trials,
+        },
+        'stages': {
+            'accuracy_candidates': candidates,
+            'selected_after_accuracy': selected_accuracy_round['summary'],
+            'efficiency_trials': efficiency_trials,
+            'selected_final': active,
         },
     }
 
-    planning_dir = repo_path / ".planning"
+    planning_dir = repo_path / '.planning'
     planning_dir.mkdir(parents=True, exist_ok=True)
-    out_path = planning_dir / "post_init_adaptation_report.json"
-    out_path.write_text(json.dumps(report, indent=2), encoding="utf-8")
-    report["report_path"] = out_path.as_posix()
+    out_path = planning_dir / 'post_init_adaptation_report.json'
+    out_path.write_text(json.dumps(report, indent=2), encoding='utf-8')
+    report['report_path'] = out_path.as_posix()
     return report
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/cli/commands/setup.py

@@ -1,7 +1,8 @@
-"""One-command repository setup for GCIE."""
+"""Repository setup and teardown helpers for GCIE."""
 
 from __future__ import annotations
 
+import shutil
 from pathlib import Path
 
 from context.architecture_bootstrap import ensure_initialized
@@ -24,6 +25,26 @@ def _copy_if_needed(source: Path, target: Path, *, force: bool) -> str:
     return "written"
 
 
+def _is_within(base: Path, target: Path) -> bool:
+    try:
+        target.resolve().relative_to(base.resolve())
+        return True
+    except ValueError:
+        return False
+
+
+def _remove_path(root: Path, target: Path) -> str:
+    if not _is_within(root, target):
+        return "skipped_outside_repo"
+    if not target.exists():
+        return "not_found"
+    if target.is_dir():
+        shutil.rmtree(target)
+        return "removed_dir"
+    target.unlink()
+    return "removed_file"
+
+
 def run_setup(
     path: str,
     *,
@@ -84,4 +105,34 @@ def run_setup(
     else:
         status["adaptation"] = {"skipped": True}
 
-    return status
+    return status
+
+
+def run_remove(
+    path: str,
+    *,
+    remove_planning: bool = False,
+    remove_gcie_usage: bool = True,
+    remove_setup_doc: bool = True,
+) -> dict:
+    """Remove GCIE-managed files from a repository."""
+    target = Path(path).resolve()
+    target.mkdir(parents=True, exist_ok=True)
+
+    removed: dict[str, str] = {}
+    removed[".gcie"] = _remove_path(target, target / ".gcie")
+
+    if remove_gcie_usage:
+        removed["GCIE_USAGE.md"] = _remove_path(target, target / "GCIE_USAGE.md")
+
+    if remove_setup_doc:
+        removed["SETUP_ANY_REPO.md"] = _remove_path(target, target / "SETUP_ANY_REPO.md")
+
+    if remove_planning:
+        removed[".planning"] = _remove_path(target, target / ".planning")
+
+    return {
+        "repo": target.as_posix(),
+        "removed": removed,
+        "remove_planning": remove_planning,
+    }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmaddire/gcie",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "GraphCode Intelligence Engine one-command setup and context CLI",
   "bin": {
     "gcie": "bin/gcie.js",