code-context-control 2.34.0__py3-none-any.whl → 2.35.0__py3-none-any.whl

cli/c3.py

@@ -85,7 +85,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.34.0"
+__version__ = "2.35.0"
 
 
 def _command_deps() -> CommandDeps:

cli/mcp_server.py

@@ -604,9 +604,10 @@ async def c3_edit(file_path: str, old_string: str = "", new_string: str = "",
 async def c3_edits(action: str, file: str = "", change_type: str = "modified",
              summary: str = "", lines_changed: str = "", tags: str = "",
              limit: int = 50, since: str = "", edit_id: str = "",
-             tag: str = "", ctx: Context = None) -> str:
+             tag: str = "", branch: str = "", ctx: Context = None) -> str:
     """EDIT HISTORY — inspect the ledger. Different from c3_edit (which writes); this one reads.
-    actions: log (append entry), history (recent edits), versions (per-file), stats, tag (mark edit_id)."""
+    actions: log (append entry), history (recent edits), versions (per-file), stats, tag (mark edit_id).
+    branch: filter history to edits stamped with a given git branch."""
     svc = _svc(ctx)
 
     def finalize(name, args, resp, summ, **kw):
@@ -615,7 +616,7 @@ async def c3_edits(action: str, file: str = "", change_type: str = "modified",
     from cli.tools.edits import handle_edits
     return await asyncio.to_thread(handle_edits, action, file, change_type, summary,
                                    lines_changed, tags, limit, since, edit_id, tag,
-                                   svc, finalize)
+                                   svc, finalize, branch)
 
 
 @mcp.tool()

cli/tools/edits.py

@@ -3,7 +3,7 @@
 
 def handle_edits(action: str, file: str, change_type: str, summary: str,
                  lines_changed: str, tags: str, limit: int, since: str,
-                 edit_id: str, tag: str, svc, finalize) -> str:
+                 edit_id: str, tag: str, svc, finalize, branch: str = "") -> str:
     """Route c3_edits actions."""
     ledger = svc.edit_ledger
     if ledger is None:
@@ -64,12 +64,17 @@ def handle_edits(action: str, file: str, change_type: str, summary: str,
             file=file or None,
             limit=limit or 50,
             since=since or None,
+            branch=branch or None,
         )
         if not entries:
             return finalize("c3_edits", {"action": "history"}, "No edits found", "0 edits")
-        lines = [f"[edits:history] {len(entries)} entries" + (f" for {file}" if file else "")]
+        scope = (f" for {file}" if file else "") + (f" on {branch}" if branch else "")
+        lines = [f"[edits:history] {len(entries)} entries" + scope]
         for e in entries:
             ln = f"  {e['timestamp'][:19]} | {e['file']} {e['version']} | {e['change_type']} | {e['summary']}"
+            br = (e.get("git") or {}).get("branch")
+            if br:
+                ln += f" @{br}"
             if e.get("tags"):
                 ln += f" [{','.join(e['tags'])}]"
             lines.append(ln)

{code_context_control-2.34.0.dist-info → code_context_control-2.35.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.34.0
+Version: 2.35.0
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). Retrieve less, read less, edit safer.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0
@@ -245,7 +245,7 @@ C3 exposes 16 tools as a native MCP server. Your IDE calls them directly:
 | `c3_impact` | Blast-radius analysis before edits to shared symbols |
 | `c3_delegate` | Offload heavy work to local Ollama / Codex / Gemini / etc. |
 | `c3_agent` | Multi-step agentic workflows (review, investigate, refactor) |
-| `c3_edits` | Edit-ledger queries + version diffs + restore points |
+| `c3_edits` | Edit-ledger queries + version diffs + restore points + per-branch filter |
 | `c3_bitbucket` | Bitbucket Data Center integration — PRs, branches, builds, repo admin (v2.30.0) |
 | `c3_project` | Cross-project — discover & operate on other c3-installed projects; guarded writes (v2.31.0) |
 

{code_context_control-2.34.0.dist-info → code_context_control-2.35.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 cli/__init__.py,sha256=ec66drCZGNMRU4V6ov0zVhYZph1us12Vn8OvG_LJyRY,22
 cli/_hook_utils.py,sha256=1_hTA-Wz62xB8jnSAH4C5TfCkrwEP0g2kq_-oRfQLm4,3724
-cli/c3.py,sha256=HjB3HjT9iFIy9WHLZbJx6cYruhxUs2iiWFw9T2Y1ECQ,289101
+cli/c3.py,sha256=lHmkT56LCHB7_NRNRXjqP8kXUWuzgfTKN9vevA7uj6M,289101
 cli/docs.html,sha256=JgtBFUuUkvmYowPREYiGhhcRbB5e2UjkRc00MIF0hsU,143653
 cli/edits.html,sha256=UjAhoCmBmQ89cklGvJqzC6eyNP2tc8H6T-e01DVkLvE,43418
 cli/hook_auto_snapshot.py,sha256=amtliVDzKUQr6KBR0pdBA8vXghAV-gKr19jBaJVnP_w,5006
@@ -17,7 +17,7 @@ cli/hook_terse_advisor.py,sha256=pD7Bap7OYOKqtYz7cX8nWSRLH7ook-tSD2Ov2MNp_sA,590
 cli/hub.html,sha256=Hl-XPZGT1mMiKrbX9c5OsEw6mXEumwIB3vp1WlWaplM,183966
 cli/hub_server.py,sha256=L7M3PAQNiRFyqdgL0COXIzIo9lyJTaCZSk-K1I2kZtM,59725
 cli/mcp_proxy.py,sha256=92htuT-p0j-cDTbyqlIJpGoQ85_Aw7UuB8L_Toi_u20,17511
-cli/mcp_server.py,sha256=5cyXOhH_CxJFCpG13AsOEvtdLZAM8_OiI9ZH1xXtZLs,32454
+cli/mcp_server.py,sha256=iYUB6rfGjNuiNQP-GecuXyMVa1CEihtu4dV7PhRHWqg,32549
 cli/server.py,sha256=n8CNh444AGuYMnVSSiRK9pirGh84Ap7ZTI8wuRrJCX8,119970
 cli/ui.html,sha256=xcdt74nlFEXx-0Bx6-Okw-WSVZPAXL0iukxU0ytI6CA,5694
 cli/ui_legacy.html,sha256=cI8tC6RKmE2NIJOcsu7CY-zT4VznjcbD6NTjxb_fvUY,378460
@@ -32,7 +32,7 @@ cli/tools/bitbucket.py,sha256=MBVMnREDhJiUal43cPqLUUPWyS8AGp3v3rNZ291Vkrg,27271
 cli/tools/compress.py,sha256=hgBQ6jUwvfGRmcC53vJBz_bbGD0E7T85IxD4q53rj4E,8941
 cli/tools/delegate.py,sha256=zOpa03znY27_y1u7T7wbfgQXPwCDA409z9dJ2ki4esU,46947
 cli/tools/edit.py,sha256=fVIZzBPe3ixKBxcZFU03ur2XKu9rAlBihga2-tmIuWw,13791
-cli/tools/edits.py,sha256=-Tv5eqw_X-dYc9l4kFWr_8vX1TAUb9QNMv0fpy0rXjQ,5304
+cli/tools/edits.py,sha256=8zM01TzLmjm7ULQlCmXOmitlJd84zQHVzE0z7UHJUdA,5520
 cli/tools/filter.py,sha256=IEjBdKrHxYVCm4cP0Ao6WZkKhbIBi1uI-mLY627zEUw,11503
 cli/tools/impact.py,sha256=jjWkFTxHu-gBpZZNd2HTdBl22itA6-wwwOZXxk_qBl8,6257
 cli/tools/memory.py,sha256=OdYBcIEFo4sr5aCG0_uO48uyJ-Kzof7LC2Ou1THGFuc,23317
@@ -57,7 +57,7 @@ cli/ui/components/memory.js,sha256=v5IsHTxLHpXX4xCsUaZ_UPprZEabdgP4jiWc298iV2U,2
 cli/ui/components/sessions.js,sha256=FIKtil76B8tCkAmcFV7hlj6GQ_DCJK2jCzvEmdK7NBE,30837
 cli/ui/components/settings.js,sha256=8LVTV2TQl9tcRXhXbtBEJOCBdiyk-x2QASoVYZUAuEA,71442
 cli/ui/components/sidebar.js,sha256=cAY_jwYB-o1X_wWn__VXlG4IegVObuE3NmVsuFWqxtg,7417
-code_context_control-2.34.0.dist-info/licenses/LICENSE,sha256=l8Kh5QCNWNvR6kIt8L0BUZvc2LAFiHv2c-FnsGnUZf4,11301
+code_context_control-2.35.0.dist-info/licenses/LICENSE,sha256=l8Kh5QCNWNvR6kIt8L0BUZvc2LAFiHv2c-FnsGnUZf4,11301
 core/__init__.py,sha256=TSDCEcM4V7gcZVM3w2ykJaqEUch4Dkon-rivV17T73s,2501
 core/config.py,sha256=0RBVni99wqJIxAYU6uweWVOmdI-FJvQ8d3IV5Mp1Muc,12818
 core/ide.py,sha256=9LzsDVK2LL8RVpL40l6oNGiasZ3D8OCU_9i9A0gJKBo,6876
@@ -87,23 +87,24 @@ oracle/services/tool_registry.py,sha256=V7eP-UeacN3T4We_zbJ8NdFCFCKJVSKJa4zfH02L
 services/__init__.py,sha256=3Kn4cZweLm7at8wFdBdZ-Zwo8hHcnVIsmY5f29nzi2Y,116
 services/activity_log.py,sha256=YsW8-HBQEFh2vYTlvnzK7doNsR-XEtBbWXJ-324XigU,3370
 services/agent_base.py,sha256=a-gdSd_jtZtbjXo1WS8CnWCagXgKaGZd5ShcG6s0kT4,4809
-services/agents.py,sha256=f4mvmLZ1Awds3RbYjESSZFtheoybHkBb_oagvnMLyaM,67485
+services/agents.py,sha256=iDYqT4iY4Q_KmWYWGKIjp7F1A_F6so9l6n59Qk7mHmI,73275
 services/auto_memory.py,sha256=v__ZS1e68533_Yv491mZtvuZnheC63q6_uTvWhBw3Lw,14290
 services/benchmark_dashboard.py,sha256=iR-DnqnoKbqHMJ4d-ZkIvJBYfzwTa7r-jzO6j2BYDfQ,27711
 services/bitbucket_client.py,sha256=v8xGEcnIEmURvcg38XwmiCGh7-_QnjhAJEb0te_yZzQ,16107
 services/bitbucket_credentials.py,sha256=2qLA9pQMol4y95y4DJMNBsBBPUsJQCKbLFo2iiCnfvI,7364
 services/claude_md.py,sha256=iL0vUQw-5lxSQehNPvhlkUmcGPeMSCcZqP4OYG_qoYk,35092
 services/compressor.py,sha256=uSVyTYfvxFrRYupzyKj-HzkBP0RwARrGYFz_DnMSEaM,25169
-services/context_snapshot.py,sha256=upxrxcBUPX7MrOlgUo7oD9rvm2H1SJLK8FI1tgHrAjg,14045
+services/context_snapshot.py,sha256=s_klEr1SJYM9u-anMmnoemsYuIF_KUWBjz1zUo0wPgU,15662
 services/conversation_store.py,sha256=vPiMiKAE22RCBSSphgGH9Vx-lPV45SmttOwgVVWahL4,33398
 services/doc_index.py,sha256=kYcE_lQgjgG7CRmqN3Byx7MNmz1JCfm8QsrjH3u7OUI,18614
 services/e2e_benchmark.py,sha256=kHZnatL27pHT1cC1DFW3SY0B6mNpIFdVns7au48Rp04,132867
 services/e2e_evaluator.py,sha256=WRIPu6b1SrSQpHESCnIWrC1wsRp1v4UGaaNcFD1KZ5c,17672
 services/e2e_tasks.py,sha256=Ln5VbGDIcS3NY3aml5ERbgjfjLxEslmRZ8AyaYxpWEo,34524
-services/edit_ledger.py,sha256=WKfsRApgZCXz5cKeKC3JVro4j9EPmW9vgmpsZDrqFm8,17961
+services/edit_ledger.py,sha256=R0eUA2jOXY_RUuCMT52wA4hTbgaeuYbGwy_xSMxS64k,18027
 services/embedding_index.py,sha256=ZccqCH5WWQnqAmPtO1PB5W2N7OzRZARrctDBAtLgPBg,12769
 services/error_reporting.py,sha256=HZ3ru8i5RLf8nq2R4iRnTs5sm1blUxknSbv5hdxuxs0,4139
 services/file_memory.py,sha256=GnEbwdWE7TUKUR4PpSgHV7cnLys3Fa2bsLvc-XwuFgI,29188
+services/git_context.py,sha256=lhuIvGDBUTKOPqye-olgJfjv538t-jtRZLBAcs7iVoA,9506
 services/hub_service.py,sha256=Ta2ExJP1sePxb7zcHooroYXJKsylm5Ea8vQvts6-cAw,21876
 services/indexer.py,sha256=ZceGqvd1OheN-hvSg4jjjXNcFjCSCgswKf5DmI-xaqA,27044
 services/memory.py,sha256=uH3hWWUCy8p_0hVuJq-pzp2F5qNRLcVOpaFYmap2VFY,12458
@@ -124,14 +125,14 @@ services/retrieval_broker.py,sha256=9X67VZ_6AkbAzopHuuMFKmP4CGZLnW576kjSKMenBnw,
 services/router.py,sha256=Cz10nx2fKTbaGn14mSBePWIDrw5rdcs_1JFYXeik084,15626
 services/runtime.py,sha256=SOUizCDW1FFTDCoaZ1Njozjp25Bhah7lR1f0WYscaw0,11361
 services/session_benchmark.py,sha256=qw_vtDim1hvFdM8Me5EsgU9pTuJhzRjQmh6m7DDnXWY,98989
-services/session_manager.py,sha256=TVG1Jf5FuVSeVrnCKTPXEDnyPp4bjRqDl4bWXP6_Cf4,43190
+services/session_manager.py,sha256=Px7RpTS6zDSuxj2O87o-7tkR8l-faMZxBX1gd5RLHfo,43837
 services/session_preloader.py,sha256=DsTAXMKVtrX9yu1sEFojYDi9-jkSAj1Ylt9JTy57Dow,9883
 services/text_index.py,sha256=r3o4CobTG9jAO9PWazgbWYLY9oi_FgEJ3xwEXrF4KM0,2783
 services/tool_classifier.py,sha256=Fgvq0ZcpnCskwtO8a3YI1MiecPNnw6UbPyJQIUwgfiQ,6512
 services/transcript_index.py,sha256=VQhvgkSyLVEYamXi_YIbiIhBnd0mqFHZlWG2HQu_1EA,12144
 services/validation_cache.py,sha256=skFYR7CkSGvFb2gq6dfxOnvjQzz5Boa3jJWT7UfaIhY,5587
 services/vector_store.py,sha256=o1RdZgRegFWlrr_kgSrY243W4KURmo4gvnP7vrxa2DE,11425
-services/version_tracker.py,sha256=Q_2Z2Fw2VkSyWmL9QF2SU9z7Y1w1zQ-80iqX93SsHn0,10130
+services/version_tracker.py,sha256=8yQAcZuJjzq1Efib828FMOjQNIcVQvPQC5KksbWLSUw,9880
 services/watcher.py,sha256=TT8dvUHw1z7Uc2KCbyynkkN4luns6qxsicc2_cj9PM8,6856
 services/bench/__init__.py,sha256=WLEJIWJeaUj6FnH2nDO1qWugJDKfOKeM6WvKLSreYjI,231
 services/bench/external/__init__.py,sha256=XgPS99ztx9igMd6x-1bLykcaePGXctkb6ujQ1MLgKAs,608
@@ -155,8 +156,8 @@ tui/screens/search_view.py,sha256=MMHjVdlk3HZSuDBSvq8IGrqv_Mh5Us6YqXQ80bcWSMk,19
 tui/screens/session_view.py,sha256=eZ1eDwHTvPOck1wCCviixtOaCxIkBT_95ytNNNriGNA,5991
 tui/screens/stats.py,sha256=p81PjzdaIv7hllb8f45-rlVe4lJZwSdIMqu7e86_u5s,6223
 tui/screens/ui_view.py,sha256=1QJCgLh2YfgWIpvzRG1KOGXYEaOYX6ojN61Azjf2oX0,2125
-code_context_control-2.34.0.dist-info/METADATA,sha256=jxMVmOACpAqMpGaXua2LZPZdLxHrkefk02mqcaRMNKI,19802
-code_context_control-2.34.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-code_context_control-2.34.0.dist-info/entry_points.txt,sha256=7kX_WUsDCF2hbXzvbNyscyaBb9AeA-DJY5v_5hN0DlU,93
-code_context_control-2.34.0.dist-info/top_level.txt,sha256=wRt41zBybVF3qAiNXHz9BURbkKvUvfhmWWtKMhaw6eE,29
-code_context_control-2.34.0.dist-info/RECORD,,
+code_context_control-2.35.0.dist-info/METADATA,sha256=BGKYwuZVthBqtj3BfoOXk7OvsfXi10ys2RX03fu90gw,19822
+code_context_control-2.35.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+code_context_control-2.35.0.dist-info/entry_points.txt,sha256=7kX_WUsDCF2hbXzvbNyscyaBb9AeA-DJY5v_5hN0DlU,93
+code_context_control-2.35.0.dist-info/top_level.txt,sha256=wRt41zBybVF3qAiNXHz9BURbkKvUvfhmWWtKMhaw6eE,29
+code_context_control-2.35.0.dist-info/RECORD,,

services/agents.py

@@ -11,6 +11,7 @@ from collections import Counter
 from pathlib import Path
 
 from services.agent_base import BackgroundAgent  # noqa: F401 — re-exported for consumers
+from services.git_context import GitContext
 
 
 class IndexStalenessAgent(BackgroundAgent):
@@ -922,6 +923,137 @@ class FileMemoryAgent(BackgroundAgent):
         return status
 
 
+class BranchWatchAgent(BackgroundAgent):
+    """Detects branch / HEAD changes and queues a scoped, targeted re-index.
+
+    Change detection keys on the HEAD sha, so it fires on checkout, switch,
+    pull, and merge — but NOT on ``git fetch`` (which only moves remote refs;
+    the working tree is untouched). On a move it queues exactly the files that
+    differ between the old and new HEAD (from ``git diff``), restricted to files
+    C3 already tracks and that genuinely need re-indexing, then notifies
+    (warning on a branch switch, info on a same-branch HEAD move).
+
+    Every cycle it also queues tracked files that are dirty on disk, catching
+    edits made outside C3 (rebase, ``git restore``, another editor) that the
+    lazy mtime-on-access path would only notice later. The actual re-extraction
+    is done by FileMemoryAgent, which drains the same queue.
+    """
+
+    def __init__(self, file_memory, notifications, project_path,
+                 enabled=True, interval=30, max_queue=200, **kwargs):
+        super().__init__("BranchWatch", interval, notifications, enabled, **kwargs)
+        self.file_memory = file_memory
+        self.project_path = project_path
+        self.max_queue = max_queue
+        self._git = GitContext(project_path)
+        self._state_path = Path(project_path) / ".c3" / "branch_state.json"
+        self._loaded = False
+        self._last = {"branch": None, "head_sha": ""}
+
+    def _load_state(self):
+        if self._loaded:
+            return
+        self._loaded = True
+        try:
+            if self._state_path.exists():
+                data = json.loads(self._state_path.read_text(encoding="utf-8"))
+                self._last = {"branch": data.get("branch"),
+                              "head_sha": data.get("head_sha", "")}
+        except Exception:
+            pass
+
+    def _save_state(self, branch, head_sha):
+        self._last = {"branch": branch, "head_sha": head_sha}
+        try:
+            self._state_path.write_text(
+                json.dumps({"branch": branch, "head_sha": head_sha}),
+                encoding="utf-8",
+            )
+        except Exception:
+            pass
+
+    def _queue_changed(self, paths) -> int:
+        """Queue tracked files that still need re-indexing; return count queued.
+
+        Paths are compared slash-agnostically against the file-memory store and
+        filtered through ``needs_update`` so unchanged files (e.g. after a local
+        commit where the working tree already matches) are not re-processed.
+        """
+        if not paths:
+            return 0
+        tracked = {t.replace("\\", "/"): t for t in self.file_memory.list_tracked()}
+        queued = 0
+        for p in paths:
+            canonical = tracked.get(p.replace("\\", "/"))
+            if canonical is None:
+                continue
+            try:
+                if not self.file_memory.needs_update(canonical):
+                    continue
+            except Exception:
+                pass
+            self.file_memory.queue_for_update(canonical)
+            queued += 1
+            if queued >= self.max_queue:
+                break
+        return queued
+
+    def check(self):
+        st = self._git.state(force=True)
+        if not st.get("available"):
+            return False  # no git here — idle backoff
+        self._load_state()
+        cur_branch = st.get("branch")
+        cur_head = st.get("head_sha", "")
+        if not cur_head:
+            return False
+        prev_branch = self._last.get("branch")
+        prev_head = self._last.get("head_sha", "")
+
+        # Catch out-of-band working-tree edits every cycle.
+        dirty_queued = self._queue_changed(self._git.dirty_files())
+
+        # First run for this project — record the baseline without notifying.
+        if not prev_head:
+            self._save_state(cur_branch, cur_head)
+            return False if dirty_queued == 0 else None
+
+        if cur_head == prev_head and cur_branch == prev_branch:
+            return False if dirty_queued == 0 else None
+
+        # HEAD or branch moved — scope the re-index to what actually differs.
+        changed = self._git.changed_files(prev_head, cur_head)
+        if not changed:
+            # Old commit unreachable / diff failed — fall back to dirty set.
+            changed = self._git.dirty_files()
+        queued = self._queue_changed(changed)
+
+        switched = (cur_branch != prev_branch)
+        self._save_state(cur_branch, cur_head)
+
+        new_label = cur_branch or "(detached)"
+        if switched:
+            old_label = prev_branch or (prev_head[:8] if prev_head else "?")
+            self.notify(
+                "warning", "Branch changed",
+                f"{old_label} → {new_label}; queued {queued} tracked file(s) for re-index",
+                replace_if_unacked=True,
+            )
+        else:
+            self.notify(
+                "info", "Index refresh",
+                f"HEAD {prev_head[:8]}→{cur_head[:8]} on {new_label}; "
+                f"queued {queued} file(s) for re-index",
+                replace_if_unacked=True,
+            )
+        return None
+
+    def get_status(self) -> dict:
+        status = super().get_status()
+        status["branch"] = self._git.label()
+        return status
+
+
 class AutonomyPlannerAgent(BackgroundAgent):
     """Builds a prioritized autonomous action plan from recent tool telemetry."""
 
@@ -1511,6 +1643,19 @@ def create_agents(services, notifications, config=None, ollama=None) -> list:
             )
         )
 
+    # BranchWatchAgent — needs file_memory's re-index queue.
+    if hasattr(services, 'file_memory') and services.file_memory:
+        agents.append(
+            BranchWatchAgent(
+                file_memory=services.file_memory,
+                notifications=notifications,
+                project_path=getattr(services, 'project_path', None),
+                **_cfg("BranchWatch", {
+                    "enabled": True, "interval": 30, "max_queue": 200,
+                }),
+            )
+        )
+
     # EditLedgerEnricherAgent — only if edit_ledger is available
     if getattr(services, 'edit_ledger', None):
         agents.append(

services/context_snapshot.py

@@ -9,6 +9,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 
 from core import count_tokens
+from services.git_context import GitContext
 
 # Max characters per file structural map stored in snapshot
 _FILE_MAP_MAX_CHARS = 600
@@ -21,6 +22,7 @@ class ContextSnapshot:
         self.project_path = Path(project_path)
         self.data_dir = self.project_path / data_dir
         self.data_dir.mkdir(parents=True, exist_ok=True)
+        self._git = GitContext(self.project_path)
 
     def capture(self, session_mgr, memory_store,
                 task_description: str = "",
@@ -88,11 +90,23 @@ class ContextSnapshot:
         # Context budget snapshot
         budget = session.get("context_budget", {})
 
+        # Git working-tree state — lets restore flag a branch change.
+        try:
+            gstate = self._git.state(force=True)
+            git_info = {
+                "branch": gstate.get("branch"),
+                "head_sha": gstate.get("head_sha", ""),
+                "detached": gstate.get("detached", False),
+            }
+        except Exception:
+            git_info = {"branch": None, "head_sha": "", "detached": False}
+
         snapshot = {
             "schema_version": 3,
             "snapshot_id": datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S"),
             "created": datetime.now(timezone.utc).isoformat(),
             "session_id": session_id,
+            "git": git_info,
             "task_description": task_description,
             "working_files": working_files or [],
             "custom_notes": custom_notes,
@@ -152,6 +166,20 @@ class ContextSnapshot:
         if "error" in snap:
             return snap
 
+        # Flag when the working tree has moved off the branch this was taken on.
+        snap_git = snap.get("git") or {}
+        if snap_git.get("branch"):
+            try:
+                cur = self._git.state(force=True)
+                if (cur.get("available") and cur.get("branch")
+                        and cur["branch"] != snap_git["branch"]):
+                    snap["_branch_warning"] = (
+                        f"snapshot taken on '{snap_git['branch']}', "
+                        f"now on '{cur['branch']}'"
+                    )
+            except Exception:
+                pass
+
         # Enrich with live memory recall so cross-session facts are surfaced immediately
         if memory_store and snap.get("task_description"):
             try:
@@ -252,6 +280,13 @@ class ContextSnapshot:
         parts = [f"# Context Restore: {snap.get('task_description', 'N/A')}"]
         parts.append(f"Snapshot: {snap['snapshot_id']} | Session: {snap.get('session_id', '?')}")
 
+        git = snap.get("git") or {}
+        if git.get("head_sha"):
+            label = (git.get("branch") or "(detached)") + " @ " + git["head_sha"][:8]
+            parts.append(f"Branch: {label}")
+        if snap.get("_branch_warning"):
+            parts.append(f"\n⚠️ Branch changed since snapshot — {snap['_branch_warning']}")
+
         if snap.get("custom_notes"):
             parts.append(f"\n## Notes\n{snap['custom_notes']}")
 
@@ -328,6 +363,8 @@ class ContextSnapshot:
     def _compact_briefing(self, snap: dict) -> str:
         """Level 1: Compact briefing — top decisions + file list."""
         parts = [f"[restore:{snap['snapshot_id']}] {snap.get('task_description', '')}"]
+        if snap.get("_branch_warning"):
+            parts.append(f"⚠️ branch changed — {snap['_branch_warning']}")
 
         plans = snap.get("plans", [])
         if plans:

services/edit_ledger.py

@@ -15,6 +15,8 @@ from collections import Counter
 from datetime import datetime, timezone
 from pathlib import Path
 
+from services.git_context import GitContext
+
 
 class EditLedger:
     """Tracks every AI edit with version numbering and git context."""
@@ -23,7 +25,8 @@ class EditLedger:
         self.project_path = Path(project_path).resolve()
         self.ledger_file = self.project_path / ".c3" / "edit_ledger.jsonl"
         self.ledger_file.parent.mkdir(parents=True, exist_ok=True)
-        self._git_root = self._detect_git_root()
+        self._git = GitContext(self.project_path)
+        self._git_root = self._git.git_root
         # In-memory caches — loaded lazily on first use, updated on writes
         self._version_cache: dict[str, int] | None = None  # {file: max_version}
         self._total_count: int | None = None
@@ -75,7 +78,8 @@ class EditLedger:
         self._seq_counter += 1
 
         # Git info — single combined command when enabled
-        git_info = {"commit": "", "author": "", "subject": "", "dirty": False}
+        git_info = {"commit": "", "author": "", "subject": "", "dirty": False,
+                    "branch": None, "head_sha": ""}
         diff_summary = ""
         if include_git and self._git_root:
             git_info, diff_summary = self._git_combined(rel)
@@ -107,9 +111,10 @@ class EditLedger:
         return entry
 
     def get_history(self, file: str = None, limit: int = 50,
-                    since: str = None) -> list:
-        """Query edits, optionally filtered by file and/or time."""
-        results = self._load_merged(file_filter=file, since_filter=since)
+                    since: str = None, branch: str = None) -> list:
+        """Query edits, optionally filtered by file, time, and/or branch."""
+        results = self._load_merged(file_filter=file, since_filter=since,
+                                    branch_filter=branch)
         return results[-limit:]
 
     def get_file_versions(self, file: str) -> list:
@@ -208,31 +213,13 @@ class EditLedger:
                 continue
         return results[-limit:]
 
-    def _detect_git_root(self):
-        """Find git root directory."""
-        try:
-            kwargs = {}
-            if sys.platform == "win32":
-                kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
-            result = subprocess.run(
-                ["git", "rev-parse", "--show-toplevel"],
-                cwd=self.project_path,
-                capture_output=True, text=True, timeout=3,
-                stdin=subprocess.DEVNULL,
-                **kwargs,
-            )
-            if result.returncode == 0:
-                return Path(result.stdout.strip()).resolve()
-        except Exception:
-            pass
-        return None
-
     def _git_combined(self, rel_path: str) -> tuple:
         """Capture git info + diff in a single subprocess call.
 
         Returns (git_info_dict, diff_summary_str).
         """
-        info = {"commit": "", "author": "", "subject": "", "dirty": False}
+        info = {"commit": "", "author": "", "subject": "", "dirty": False,
+                "branch": None, "head_sha": ""}
         diff_summary = ""
         abs_path = (self.project_path / rel_path).resolve()
         try:
@@ -296,11 +283,20 @@ class EditLedger:
         except Exception:
             pass
 
+        # Branch + HEAD from the cached GitContext (cheap; shared TTL cache).
+        try:
+            gstate = self._git.state()
+            info["branch"] = gstate.get("branch")
+            info["head_sha"] = gstate.get("head_sha", "")
+        except Exception:
+            pass
+
         return info, diff_summary
 
     # ── Async enrichment ──────────────────────────────────────────────
 
-    def _load_merged(self, file_filter: str = None, since_filter: str = None) -> list:
+    def _load_merged(self, file_filter: str = None, since_filter: str = None,
+                     branch_filter: str = None) -> list:
         """Read all base entries with any appended patches merged in.
 
         Patch entries are identified by having a 'target_id' field.
@@ -348,6 +344,8 @@ class EditLedger:
                 continue
             if since_filter and entry.get("timestamp", "") < since_filter:
                 continue
+            if branch_filter and (entry.get("git") or {}).get("branch") != branch_filter:
+                continue
             results.append(entry)
         results.sort(key=lambda e: e.get("timestamp", ""))
         return results

services/git_context.py

@@ -0,0 +1,243 @@
+"""GitContext — single source of truth for git working-tree state.
+
+Centralizes git-root detection and branch / HEAD / dirty queries so the rest
+of C3 does not re-implement subprocess plumbing (previously duplicated in
+``EditLedger`` and ``VersionTracker``). State is cached for a short TTL because
+several callers — the edit ledger, context snapshots, the branch watcher — ask
+for it in quick succession.
+
+All git calls use list-arg ``subprocess.run`` (no shell) with a timeout and the
+Windows ``CREATE_NO_WINDOW`` flag. The ``shell=True`` hang documented for the
+ledger's combined command does not apply to non-shell invocations, so the
+simple ``run(..., timeout=...)`` form is safe here.
+"""
+
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+
+def _git_kwargs() -> dict:
+    kwargs = {}
+    if sys.platform == "win32":
+        kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
+    return kwargs
+
+
+class GitContext:
+    """Cached accessor for the git working-tree state of a project path.
+
+    Branch awareness is deliberately content/ref-derived rather than persisted:
+    the index follows whatever HEAD currently points at. See ``state()`` for the
+    shape returned to callers.
+    """
+
+    def __init__(self, project_path, ttl: float = 3.0):
+        self.project_path = Path(project_path).resolve()
+        self._ttl = ttl
+        self._git_root = self._detect_git_root()
+        self._cache: dict | None = None
+        self._cache_time: float = 0.0
+
+    # ── git root ──────────────────────────────────────────────────────
+    @property
+    def git_root(self) -> Path | None:
+        return self._git_root
+
+    @property
+    def available(self) -> bool:
+        return self._git_root is not None
+
+    def _run(self, args: list, timeout: float = 3.0) -> tuple:
+        """Run a git command rooted at git_root (project_path fallback).
+
+        Returns (returncode, stdout, stderr); (None, '', '') on failure/timeout.
+        """
+        cwd = self._git_root or self.project_path
+        try:
+            proc = subprocess.run(
+                ["git", *args],
+                cwd=str(cwd),
+                capture_output=True, text=True, timeout=timeout,
+                stdin=subprocess.DEVNULL,
+                **_git_kwargs(),
+            )
+            return proc.returncode, proc.stdout or "", proc.stderr or ""
+        except Exception:
+            return None, "", ""
+
+    def _detect_git_root(self) -> Path | None:
+        try:
+            proc = subprocess.run(
+                ["git", "rev-parse", "--show-toplevel"],
+                cwd=str(self.project_path),
+                capture_output=True, text=True, timeout=3,
+                stdin=subprocess.DEVNULL,
+                **_git_kwargs(),
+            )
+            if proc.returncode == 0:
+                root = (proc.stdout or "").strip()
+                if root:
+                    return Path(root).resolve()
+        except Exception:
+            pass
+        return None
+
+    # ── working-tree state ────────────────────────────────────────────
+    @staticmethod
+    def _empty_state() -> dict:
+        return {
+            "available": False, "git_root": None, "branch": None,
+            "detached": False, "head_sha": "", "upstream": None,
+            "ahead": 0, "behind": 0, "dirty": False,
+        }
+
+    def state(self, force: bool = False) -> dict:
+        """Return cached working-tree state.
+
+        Keys: ``available``, ``git_root``, ``branch`` (None when detached),
+        ``detached``, ``head_sha`` (short), ``upstream``, ``ahead``, ``behind``,
+        ``dirty``. Cached for ``ttl`` seconds; pass ``force=True`` to refresh.
+        """
+        now = time.time()
+        if not force and self._cache is not None and (now - self._cache_time) < self._ttl:
+            return self._cache
+        self._cache = self._compute_state()
+        self._cache_time = now
+        return self._cache
+
+    def _compute_state(self) -> dict:
+        st = self._empty_state()
+        if not self._git_root:
+            return st
+        st["available"] = True
+        st["git_root"] = str(self._git_root)
+
+        rc, out, _ = self._run(["status", "--branch", "--porcelain=v2"])
+        if rc != 0:
+            # porcelain=v2 unsupported or command failed — degrade gracefully.
+            return self._fallback_state(st)
+
+        dirty = False
+        for line in out.splitlines():
+            if line.startswith("# branch.oid "):
+                sha = line[len("# branch.oid "):].strip()
+                if sha and sha != "(initial)":
+                    st["head_sha"] = sha[:12]
+            elif line.startswith("# branch.head "):
+                head = line[len("# branch.head "):].strip()
+                if head == "(detached)":
+                    st["detached"] = True
+                else:
+                    st["branch"] = head
+            elif line.startswith("# branch.upstream "):
+                st["upstream"] = line[len("# branch.upstream "):].strip()
+            elif line.startswith("# branch.ab "):
+                for token in line[len("# branch.ab "):].split():
+                    try:
+                        if token.startswith("+"):
+                            st["ahead"] = int(token[1:])
+                        elif token.startswith("-"):
+                            st["behind"] = int(token[1:])
+                    except ValueError:
+                        pass
+            elif line and not line.startswith("#"):
+                dirty = True
+        st["dirty"] = dirty
+        return st
+
+    def _fallback_state(self, st: dict) -> dict:
+        """Best-effort branch/HEAD for git versions without porcelain=v2."""
+        rc, out, _ = self._run(["rev-parse", "HEAD"])
+        if rc == 0 and out.strip():
+            st["head_sha"] = out.strip()[:12]
+        rc, out, _ = self._run(["rev-parse", "--abbrev-ref", "HEAD"])
+        if rc == 0:
+            head = out.strip()
+            if head == "HEAD":
+                st["detached"] = True
+            elif head:
+                st["branch"] = head
+        rc, out, _ = self._run(["status", "--porcelain"])
+        if rc == 0:
+            st["dirty"] = bool(out.strip())
+        return st
+
+    # ── convenience accessors ─────────────────────────────────────────
+    def branch(self) -> str | None:
+        return self.state().get("branch")
+
+    def head_sha(self) -> str:
+        return self.state().get("head_sha", "")
+
+    def label(self) -> str:
+        """Human-readable 'branch @ shortsha' (or '(detached) @ sha')."""
+        st = self.state()
+        if not st["available"]:
+            return "no-git"
+        name = st["branch"] or "(detached)"
+        sha = (st["head_sha"] or "")[:8]
+        return f"{name} @ {sha}" if sha else name
+
+    # ── change queries (scoped re-index support) ──────────────────────
+    def _to_project_rel(self, git_rel: str) -> str | None:
+        """Convert a git-root-relative path to project-relative POSIX form.
+
+        Returns None when the path lies outside ``project_path`` (e.g. a sibling
+        subdirectory of the repo, or another worktree) so callers never queue
+        files they do not track.
+        """
+        if not git_rel or not self._git_root:
+            return None
+        abs_path = (self._git_root / git_rel).resolve()
+        try:
+            return abs_path.relative_to(self.project_path).as_posix()
+        except Exception:
+            return None
+
+    def changed_files(self, old_sha: str, new_sha: str) -> list:
+        """Project-relative paths that differ between two commits.
+
+        Empty list if either sha is missing or the diff fails (e.g. the old
+        commit is no longer reachable) — callers should fall back to
+        ``dirty_files()`` in that case.
+        """
+        if not (old_sha and new_sha) or not self._git_root:
+            return []
+        rc, out, _ = self._run(["diff", "--name-only", f"{old_sha}..{new_sha}"])
+        if rc != 0:
+            return []
+        result = []
+        for line in out.splitlines():
+            rel = self._to_project_rel(line.strip())
+            if rel:
+                result.append(rel)
+        return result
+
+    def dirty_files(self) -> list:
+        """Project-relative paths with uncommitted working-tree changes.
+
+        Includes untracked files. Catches edits made outside C3 (other editors,
+        rebases, ``git restore``) that mtime-on-access would only notice later.
+        """
+        if not self._git_root:
+            return []
+        rc, out, _ = self._run(["status", "--porcelain"])
+        if rc != 0:
+            return []
+        result = []
+        for line in out.splitlines():
+            if len(line) <= 3:
+                continue
+            path = line[3:].strip()
+            # Renames render as 'old -> new'; index the new path.
+            if " -> " in path:
+                path = path.split(" -> ", 1)[1].strip()
+            # git quotes paths containing special characters.
+            if len(path) >= 2 and path.startswith('"') and path.endswith('"'):
+                path = path[1:-1]
+            rel = self._to_project_rel(path)
+            if rel:
+                result.append(rel)
+        return result

services/session_manager.py

@@ -16,6 +16,7 @@ from typing import Optional
 
 from core import count_tokens
 from core.ide import detect_ide, load_ide_config
+from services.git_context import GitContext
 
 
 class SessionManager:
@@ -49,6 +50,7 @@ class SessionManager:
         self.data_dir.mkdir(parents=True, exist_ok=True)
         self.current_session = None
         self.ollama_client = ollama_client
+        self._git = None
 
         # Analytics now in a dedicated directory
         analytics_dir = self.project_path / ".c3" / "analytics"
@@ -94,6 +96,20 @@ class SessionManager:
             ide_name = detect_ide(str(self.project_path))
         return ide_name or "claude-code"
 
+    def _git_state(self) -> dict:
+        """Current git branch/HEAD for stamping on the session (lazy, cached)."""
+        try:
+            if self._git is None:
+                self._git = GitContext(self.project_path)
+            st = self._git.state()
+            return {
+                "branch": st.get("branch"),
+                "head_sha": st.get("head_sha", ""),
+                "detached": st.get("detached", False),
+            }
+        except Exception:
+            return {"branch": None, "head_sha": "", "detached": False}
+
     def start_session(self, description: str = "", source_system: Optional[str] = None) -> dict:
         """Start a new session."""
         session_id = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
@@ -108,6 +124,7 @@ class SessionManager:
             "description": description,
             "source_system": source_system_value,
             "source_ide": source_ide,
+            "git": self._git_state(),
             "decisions": [],
             "files_touched": [],
             "key_changes": [],

services/version_tracker.py

@@ -7,6 +7,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 
 from core.ide import get_profile
+from services.git_context import GitContext
 
 
 class VersionTracker:
@@ -20,7 +21,8 @@ class VersionTracker:
         self.ide_name = ide_name
         self.store_path = self.project_path / ".c3" / "version_tracker.json"
         self.store_path.parent.mkdir(parents=True, exist_ok=True)
-        self._git_root = self._detect_git_root()
+        self._git = GitContext(self.project_path)
+        self._git_root = self._git.git_root
         self.state = self._load_state()
 
     def scan(self, agent: str = "current", max_files: int | None = None) -> dict:
@@ -163,21 +165,6 @@ class VersionTracker:
         except Exception:
             return ""
 
-    def _detect_git_root(self) -> Path | None:
-        try:
-            result = subprocess.run(
-                ["git", "rev-parse", "--show-toplevel"],
-                cwd=self.project_path,
-                capture_output=True,
-                text=True,
-                timeout=3,
-                check=True,
-            )
-            root = (result.stdout or "").strip()
-            return Path(root).resolve() if root else None
-        except Exception:
-            return None
-
     def _git_info(self, rel_path: str) -> dict:
         info = {
             "available": bool(self._git_root),
@@ -187,6 +174,7 @@ class VersionTracker:
             "author": "",
             "timestamp": 0,
             "subject": "",
+            "branch": None,
         }
         if not self._git_root:
             return info
@@ -251,6 +239,10 @@ class VersionTracker:
                 info["subject"] = parts[3]
         except Exception:
             pass
+        try:
+            info["branch"] = self._git.state().get("branch")
+        except Exception:
+            pass
         return info
 
     def _load_state(self) -> dict: