@pmaddire/gcie 0.1.8 → 0.1.9

package/cli/commands/adaptation.py

@@ -1,509 +1,576 @@
-"""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, pipeline_status: str, cost_analysis: 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": 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_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
-
-    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)
-
-    pipeline_status = "ok"
-    if (
-        active.get("full_hit_rate_pct", 0.0) >= 100.0
-        and active.get("label") != cheapest.get("label")
-        and pct_delta > 40.0
-    ):
-        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",
-    }
-
-    _write_back(repo_path, active, case_source, pipeline_status, cost_analysis)
-
-    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,
-        },
-    }
-
-    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()
+"""Post-initialization adaptation pipeline (accuracy rounds first, then efficiency rounds)."""
+
+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
+    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",
+}
+_METHOD_ORDER = ["plain", "plain_gapfill", "plain_rescue", "slices"]
+
+
+def _query_keywords(text: str) -> list[str]:
+    return [t for t in _WORD_RE.findall(text.lower()) if len(t) >= 4][: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}
+    return next(iter(heads)) if len(heads) == 1 else "."
+
+
+def _safe_scope(path: str) -> str:
+    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":
+        return ".", "cli/commands/context.py llm_context/context_builder.py build_context token_budget mandatory_node_ids snippet_selector", 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, 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)
+        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]
+    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):
+            gap_keywords = " ".join(_query_keywords(case.query)[:4])
+            gap_query = f"{rel} {gap_keywords}".strip()
+            scopes = [_safe_scope(_family_path((rel,)))]
+            budgets = [500 if rel.endswith('/main.py') or rel == 'main.py' else 900]
+            if aggressive_gapfill:
+                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
+
+    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 = {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='.',
+            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 _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)
+    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 _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: 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
+    for rel in files:
+        add_case(f"single_{Path(rel).stem}", (rel,), intent='explore')
+        if len(rows) >= max(needed // 2, 1):
+            break
+
+    # same-dir pairs
+    for parent, group in sorted(by_dir.items(), key=lambda x: x[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-dir pairs fallback
+    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]:
+    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 _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 = _classify_query_family(case.query)
+        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 _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'))
+            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,
+        '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')
+
+
+def run_post_init_adaptation(
+    repo: str = '.',
+    *,
+    benchmark_size: int = 10,
+    efficiency_iterations: int = 5,
+    clear_profile: bool = False,
+) -> dict:
+    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.',
+        }
+
+    families = sorted({_classify_query_family(case.query) for case in cases})
+    family_policy = {fam: 'plain' for fam in 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)
+
+        if summary['full_hit_rate_pct'] >= 100.0:
+            lock_streak += 1
+            if lock_streak >= 2:
+                break
+            continue
+
+        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:
+        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] = []
+    for idx in range(max(0, int(efficiency_iterations))):
+        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
+
+    # 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,
+    }
+
+    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('tokens_per_query', 10**9) > cheapest.get('tokens_per_query', 10**9)
+        and pct_delta > 40.0
+    ):
+        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',
+    }
+
+    _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,
+        'family_policy': family_policy,
+        'cost_analysis': cost_analysis,
+        'phases': {
+            '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.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.8",
+  "version": "0.1.9",
   "description": "GraphCode Intelligence Engine one-command setup and context CLI",
   "bin": {
     "gcie": "bin/gcie.js",