@pmaddire/gcie 0.1.5 → 0.1.7

package/cli/commands/adaptation.py

@@ -1,341 +1,486 @@
-"""Post-initialization adaptation pipeline (accuracy first, then efficiency)."""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass
-from datetime import datetime, timezone
-import json
-import re
-from pathlib import Path
-
-from .context import run_context
-from .context_slices import _classify_query_family, run_context_slices
-from .index import run_index
-
-try:
-    from performance.context_benchmark import BENCHMARK_CASES
-except Exception:  # pragma: no cover - fallback for limited installs
-    BENCHMARK_CASES = ()
-
-
-@dataclass(frozen=True, slots=True)
-class CaseResult:
-    name: str
-    family: str
-    mode: str
-    tokens: int
-    expected_hits: int
-    expected_total: int
-    missing_expected: tuple[str, ...]
-    context_complete: bool
-
-
-_WORD_RE = re.compile(r"[A-Za-z0-9_./-]+")
-
-
-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]
-
-
-def _node_to_file(node_id: str) -> str | None:
-    if node_id.startswith("file:"):
-        return node_id[5:]
-    if node_id.startswith("function:"):
-        return node_id[9:].split("::", 1)[0]
-    if node_id.startswith("class:"):
-        return node_id[6:].split("::", 1)[0]
-    return None
-
-
-def _normalize_scoped_path(plan_path: str, rel_path: str) -> str:
-    normalized = rel_path.replace("\\", "/").lstrip("./")
-    if not plan_path or plan_path in {".", "./"}:
-        return normalized
-    base = Path(plan_path).as_posix().strip("/")
-    if normalized.startswith(base + "/") or normalized == base:
-        return normalized
-    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 _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
-    return path, query, budget
-
-
-def _evaluate_plain_case(case, *, allow_gapfill: bool = True) -> CaseResult:
-    path, query, budget = _plan_query(case)
-    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
-    }
-    expected = tuple(case.expected_files)
-    missing = [rel for rel in expected if rel not in files]
-    tokens = int(payload.get("tokens", 0) or 0)
-    mode = "plain_context_workflow"
-
-    if allow_gapfill and missing:
-        mode = "plain_context_workflow_gapfill"
-        for rel in list(missing):
-            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]
-            if not missing:
-                break
-
-    expected_hits = len(expected) - len(missing)
-    family = _classify_query_family(query)
-    return CaseResult(
-        name=case.name,
-        family=family,
-        mode=mode,
-        tokens=tokens,
-        expected_hits=expected_hits,
-        expected_total=len(expected),
-        missing_expected=tuple(missing),
-        context_complete=not missing,
-    )
-
-
-def _evaluate_slices_case(case) -> CaseResult:
-    payload = run_context_slices(
-        repo=".",
-        query=case.query,
-        profile="low",
-        stage_a_budget=300,
-        stage_b_budget=600,
-        max_total=800,
-        intent=case.intent,
-        pin=None,
-        pin_budget=200,
-        include_tests=False,
-    )
-    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}
-    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=".",
-            query=case.query,
-            profile="recall",
-            stage_a_budget=400,
-            stage_b_budget=800,
-            max_total=1200,
-            intent=case.intent,
-            pin=None,
-            pin_budget=300,
-            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
-            }
-        )
-        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=".",
-                query=case.query,
-                profile="recall",
-                stage_a_budget=400,
-                stage_b_budget=800,
-                max_total=1200,
-                intent=case.intent,
-                pin=rel,
-                pin_budget=300,
-                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
-                }
-            )
-            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)
-    return CaseResult(
-        name=case.name,
-        family=family,
-        mode=mode,
-        tokens=tokens,
-        expected_hits=expected_hits,
-        expected_total=len(expected),
-        missing_expected=tuple(missing),
-        context_complete=not missing,
-    )
-
-
-def _summarize(label: str, rows: list[CaseResult]) -> dict:
-    case_count = len(rows)
-    pass_count = sum(1 for row in rows if row.context_complete)
-    total_tokens = sum(row.tokens for row in rows)
-    hit_count = sum(row.expected_hits for row in rows)
-    hit_total = sum(row.expected_total for row in rows)
-    return {
-        "label": label,
-        "case_count": case_count,
-        "passing_cases": pass_count,
-        "full_hit_rate_pct": round((pass_count / case_count) * 100, 1) if case_count else 0.0,
-        "target_hit_rate_pct": round((hit_count / hit_total) * 100, 1) if hit_total else 0.0,
-        "total_tokens": total_tokens,
-        "tokens_per_query": round(total_tokens / case_count, 1) if case_count else 0.0,
-        "tokens_per_expected_hit": round(total_tokens / hit_count, 2) if hit_count else None,
-        "results": [asdict(row) for row in rows],
-    }
-
-
-def _write_back(repo_path: Path, best: dict) -> None:
-    cfg_path = repo_path / ".gcie" / "context_config.json"
-    if cfg_path.exists():
-        try:
-            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": "complete",
-        "best_label": best.get("label"),
-        "full_hit_rate_pct": best.get("full_hit_rate_pct"),
-        "tokens_per_query": best.get("tokens_per_query"),
-        "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")
-
-
-def run_post_init_adaptation(
-    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()
-    run_index(repo_path.as_posix())
-
-    if clear_profile:
-        from .context_slices import clear_adaptive_profile
-
-        clear_adaptive_profile(repo_path.as_posix())
-
-    cases = list(BENCHMARK_CASES)
-    if not cases:
-        return {
-            "status": "no_benchmark_cases",
-            "repo": repo_path.as_posix(),
-            "message": "No benchmark cases available for accuracy-locked adaptation.",
-        }
-
-    benchmark_size = max(1, min(len(cases), int(benchmark_size)))
-    cases = cases[:benchmark_size]
-
-    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]
-
-    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)
-
-    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"]))
-    else:
-        best = max(candidates, key=lambda item: item["target_hit_rate_pct"])
-
-    efficiency_trials: list[dict] = []
-    active = best
-    for idx in range(max(0, int(efficiency_iterations))):
-        if active["label"] != "plain_gapfill_accuracy_stage":
-            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
-
-    _write_back(repo_path, active)
-
-    report = {
-        "status": "ok",
-        "repo": repo_path.as_posix(),
-        "benchmark_size": benchmark_size,
-        "efficiency_iterations": int(efficiency_iterations),
-        "stages": {
-            "accuracy_candidates": [slices_summary, plain_summary, plain_gap_summary],
-            "selected_after_accuracy": best,
-            "efficiency_trials": efficiency_trials,
-            "selected_final": active,
-        },
-    }
-
-    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()
-    return report
+"""Post-initialization adaptation pipeline (accuracy first, then efficiency)."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+import json
+import re
+from pathlib import Path
+
+from .context import run_context
+from .context_slices import _classify_query_family, run_context_slices
+from .index import run_index
+
+try:
+    from performance.context_benchmark import BENCHMARK_CASES
+except Exception:  # pragma: no cover - fallback for limited installs
+    BENCHMARK_CASES = ()
+
+
+@dataclass(frozen=True, slots=True)
+class CaseResult:
+    name: str
+    family: str
+    mode: str
+    tokens: int
+    expected_hits: int
+    expected_total: int
+    missing_expected: tuple[str, ...]
+    context_complete: bool
+
+
+@dataclass(frozen=True, slots=True)
+class AdaptCase:
+    name: str
+    query: str
+    intent: str
+    baseline_files: tuple[str, ...]
+    expected_files: tuple[str, ...]
+
+
+_WORD_RE = re.compile(r"[A-Za-z0-9_./-]+")
+_SOURCE_EXTS = {".py", ".js", ".jsx", ".ts", ".tsx", ".java", ".go", ".rs", ".cs", ".cpp", ".c", ".h"}
+_IGNORED_DIRS = {
+    ".git",
+    ".gcie",
+    ".planning",
+    ".venv",
+    "node_modules",
+    "__pycache__",
+    "dist",
+    "build",
+    "coverage",
+}
+
+
+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]
+
+
+def _node_to_file(node_id: str) -> str | None:
+    if node_id.startswith("file:"):
+        return node_id[5:]
+    if node_id.startswith("function:"):
+        return node_id[9:].split("::", 1)[0]
+    if node_id.startswith("class:"):
+        return node_id[6:].split("::", 1)[0]
+    return None
+
+
+def _normalize_scoped_path(plan_path: str, rel_path: str) -> str:
+    normalized = rel_path.replace("\\", "/").lstrip("./")
+    if not plan_path or plan_path in {".", "./"}:
+        return normalized
+    base = Path(plan_path).as_posix().strip("/")
+    if normalized.startswith(base + "/") or normalized == base:
+        return normalized
+    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 _safe_scope(path: str) -> str:
+    """Return a valid retrieval scope for the current repo."""
+    if not path or path in {".", "./"}:
+        return "."
+    candidate = Path(path)
+    if candidate.exists() and candidate.is_dir():
+        return candidate.as_posix()
+    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
+    return path, query, budget
+
+
+def _evaluate_plain_case(case, *, allow_gapfill: bool = True) -> 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
+    }
+    expected = tuple(case.expected_files)
+    missing = [rel for rel in expected if rel not in files]
+    tokens = int(payload.get("tokens", 0) or 0)
+    mode = "plain_context_workflow"
+
+    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]
+            if not missing:
+                break
+
+    expected_hits = len(expected) - len(missing)
+    family = _classify_query_family(query)
+    return CaseResult(
+        name=case.name,
+        family=family,
+        mode=mode,
+        tokens=tokens,
+        expected_hits=expected_hits,
+        expected_total=len(expected),
+        missing_expected=tuple(missing),
+        context_complete=not missing,
+    )
+
+
+def _evaluate_slices_case(case) -> CaseResult:
+    payload = run_context_slices(
+        repo=".",
+        query=case.query,
+        profile="low",
+        stage_a_budget=300,
+        stage_b_budget=600,
+        max_total=800,
+        intent=case.intent,
+        pin=None,
+        pin_budget=200,
+        include_tests=False,
+    )
+    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}
+    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=".",
+            query=case.query,
+            profile="recall",
+            stage_a_budget=400,
+            stage_b_budget=800,
+            max_total=1200,
+            intent=case.intent,
+            pin=None,
+            pin_budget=300,
+            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
+            }
+        )
+        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=".",
+                query=case.query,
+                profile="recall",
+                stage_a_budget=400,
+                stage_b_budget=800,
+                max_total=1200,
+                intent=case.intent,
+                pin=rel,
+                pin_budget=300,
+                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
+                }
+            )
+            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)
+    return CaseResult(
+        name=case.name,
+        family=family,
+        mode=mode,
+        tokens=tokens,
+        expected_hits=expected_hits,
+        expected_total=len(expected),
+        missing_expected=tuple(missing),
+        context_complete=not missing,
+    )
+
 
+def _summarize(label: str, rows: list[CaseResult]) -> dict:
+    case_count = len(rows)
+    pass_count = sum(1 for row in rows if row.context_complete)
+    total_tokens = sum(row.tokens for row in rows)
+    hit_count = sum(row.expected_hits for row in rows)
+    hit_total = sum(row.expected_total for row in rows)
+    return {
+        "label": label,
+        "case_count": case_count,
+        "passing_cases": pass_count,
+        "full_hit_rate_pct": round((pass_count / case_count) * 100, 1) if case_count else 0.0,
+        "target_hit_rate_pct": round((hit_count / hit_total) * 100, 1) if hit_total else 0.0,
+        "total_tokens": total_tokens,
+        "tokens_per_query": round(total_tokens / case_count, 1) if case_count else 0.0,
+        "tokens_per_expected_hit": round(total_tokens / hit_count, 2) if hit_count else None,
+        "results": [asdict(row) for row in rows],
+    }
 
+
+def _collect_source_files(repo_path: Path) -> list[str]:
+    files: list[str] = []
+    for path in repo_path.rglob("*"):
+        if not path.is_file():
+            continue
+        rel = path.relative_to(repo_path)
+        if any(part in _IGNORED_DIRS for part in rel.parts):
+            continue
+        if path.suffix.lower() not in _SOURCE_EXTS:
+            continue
+        files.append(rel.as_posix())
+    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:
+        return []
+
+    by_dir: dict[str, list[str]] = {}
+    for rel in files:
+        parent = str(Path(rel).parent).replace("\\", "/")
+        by_dir.setdefault(parent, []).append(rel)
+
+    rows: list[AdaptCase] = []
+    seen_names: set[str] = set()
+
+    def add_case(name: str, expected: tuple[str, ...], intent: str = "explore") -> None:
+        if len(rows) >= needed:
+            return
+        safe_name = re.sub(r"[^a-zA-Z0-9_]+", "_", name).strip("_").lower() or "case"
+        if safe_name in seen_names:
+            idx = 2
+            while f"{safe_name}_{idx}" in seen_names:
+                idx += 1
+            safe_name = f"{safe_name}_{idx}"
+        seen_names.add(safe_name)
+        symbols = []
+        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.
+    for rel in files:
+        add_case(f"single_{Path(rel).stem}", (rel,), intent="explore")
+        if len(rows) >= max(needed // 2, 1):
+            break
+
+    # Same-directory pairs.
+    for parent, group in sorted(by_dir.items(), key=lambda item: item[0]):
+        if len(group) < 2:
+            continue
+        group = sorted(group)
+        for idx in range(len(group) - 1):
+            add_case(f"pair_{parent}_{idx}", (group[idx], group[idx + 1]), intent="explore")
+            if len(rows) >= needed:
+                return rows[:needed]
+
+    # Cross-directory pairs if still needed.
+    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")
+        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) -> None:
+    cfg_path = repo_path / ".gcie" / "context_config.json"
+    if cfg_path.exists():
+        try:
+            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": "complete",
+        "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,
+        "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")
+
+
+def run_post_init_adaptation(
+    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()
+    run_index(repo_path.as_posix())
+
+    if clear_profile:
+        from .context_slices import clear_adaptive_profile
+
+        clear_adaptive_profile(repo_path.as_posix())
+
+    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.",
+        }
+
+    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]
+
+    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)
+
+    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"]))
+    else:
+        best = max(candidates, key=lambda item: item["target_hit_rate_pct"])
+
+    efficiency_trials: list[dict] = []
+    active = best
+    for idx in range(max(0, int(efficiency_iterations))):
+        if active["label"] != "plain_gapfill_accuracy_stage":
+            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
+
+    _write_back(repo_path, active, case_source)
+
+    report = {
+        "status": "ok",
+        "repo": repo_path.as_posix(),
+        "benchmark_size": len(cases),
+        "requested_benchmark_size": int(benchmark_size),
+        "efficiency_iterations": int(efficiency_iterations),
+        "case_source": case_source,
+        "stages": {
+            "accuracy_candidates": [slices_summary, plain_summary, plain_gap_summary],
+            "selected_after_accuracy": best,
+            "efficiency_trials": efficiency_trials,
+            "selected_final": active,
+        },
+    }
+
+    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()
+    return report

package/package.json

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