research-git 0.0.4__tar.gz → 0.0.6__tar.gz

{research_git-0.0.4/src/research_git.egg-info → research_git-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: research-git
-Version: 0.0.4
+Version: 0.0.6
 Summary: A memory system that captures code ideas as semantic capsules you can regenerate onto today's codebase
 Author: Stepzero Lab
 License-Expression: MIT
@@ -94,65 +94,58 @@ Capsules live in a small graph beside your repo (`.rgit/`), on top of normal git
 
 ## 🚀 Quick Start
 
-Five steps: install → init → run → capture → recall.
-
 ### 1. Install
 
 ```bash
-pip install research-git        # or, from a clone: pip install -e .
-
-# wire the plugin (agents + skills) and the MCP server into your client
-rgit install                    # auto-detects every agent client on this machine and wires them all
-rgit install claude-code        # or pick one explicitly (claude-code / codex / gemini / opencode / generic)
-rgit install --list             # list platforms; --uninstall to remove
+pip install research-git
+rgit install        # wires research-git into every agent client on this machine
+cd your-project
+rgit init           # creates the .rgit/ store in your repo
 ```
 
-`codex`, `gemini`, and `opencode` share the `~/.agents/skills/` convention — the installer symlinks each skill there and prints the one-line MCP server entry to drop into that client's config. It also writes a managed research-git guidance block into the client's global guidance file when the platform has one (`~/.codex/AGENTS.md`, `~/.claude/CLAUDE.md`, or `~/.gemini/GEMINI.md`). On an interactive terminal you're asked how proactive capture should be — `default`, `manual-only`, or `none`; pass `--guidance <mode>` to choose non-interactively. Start a new agent session after install so the guidance is loaded. Prefer the manual route on Claude Code? `/plugin marketplace add StepzeroLab/research-git` then `/plugin install research-git@research-git`.
+That's the whole setup. Start a new agent session afterwards so it picks everything up.
 
-### 2. Initialize in your repo
+<details>
+<summary>Install details: choosing platforms, guidance modes, capture-on-commit</summary>
 
-```bash
-cd your-project
-rgit init                       # creates .rgit/ (the store) at the git root
-```
+- `rgit install claude-code` (or `codex` / `gemini` / `opencode` / `generic`) targets one client; `--list` shows all; `--uninstall` removes.
+- The installer also writes a short guidance block into your client's global file (`~/.claude/CLAUDE.md`, `~/.codex/AGENTS.md`, …) so the agent knows when to save ideas. On an interactive terminal you pick how proactive that should be (`default` / `manual-only` / `none`); pass `--guidance <mode>` to choose non-interactively.
+- **Optional:** `rgit install-hooks` (per repo) makes every `git commit` stage its own snapshot automatically, so nothing slips through even when you forget. It never touches an existing hook, hooks never approve anything, and `rgit install-hooks --uninstall` removes it. Skip it in CI or shared clones.
+- Manual route on Claude Code: `/plugin marketplace add StepzeroLab/research-git` then `/plugin install research-git@research-git`.
 
-**Optional — capture on every commit.** `rgit install <platform>` wires the agent side only; it deliberately does **not** touch your git hooks. If you also want every `git commit` to stage its own diff as a pending proposal automatically, opt in with:
+</details>
 
-```bash
-rgit install-hooks              # adds a post-commit hook (never clobbers an existing one)
-```
+### 2. Working with an agent? Just talk to it
 
-Good fit: solo research repos where you want nothing to slip through, even when you forget to capture. Skip it if the repo already has its own post-commit hook (the installer refuses to touch foreign hooks, so nothing breaks — it just won't install), if your team prefers deliberate manual capture, or in CI/shared clones where commit-time side effects are unwelcome. Without hooks you lose nothing: bare `rgit capture` takes the last commit when the tree is clean, `rgit capture A..B` a whole span, and `rgit review` is the gate either way — hooks only stage proposals, they never approve anything. Remove with `rgit install-hooks --uninstall`.
+After install your agent does the remembering. Work as usual — it saves each meaningful idea as a Feature Capsule (asking you before anything is kept). Weeks later, when the code has moved on, just ask:
 
-### 3. Run a variation and capture the idea
+> *"bring back the re-ranking retrieval step"*
 
-Launch your work through `rgit run` — it executes your command, freezes a reproducible artifact, records the run + any metrics, and stages what changed:
+The agent finds the capsule and **re-implements the idea onto today's code**, leaving you a reviewable diff. No commands to memorize — but if you like being explicit, `/rgit-capture` saves recent work and `/rgit-recall <what you want back>` brings an idea home.
+
+### 3. Working in the terminal? Three commands
 
 ```bash
-rgit run -- python eval_agent.py --retrieval rerank
+rgit run -- python eval_agent.py --retrieval rerank   # run an experiment; freezes a byte-exact snapshot + metrics
+rgit review                                           # see what's been captured, approve what's worth keeping
+rgit compare rerank                                   # which variant won?
 ```
 
-Then turn that raw material into a clean capsule (in a Claude Code session):
-
-```
-/rgit-capture            # segments the diff into Feature Capsules, then wires up graph edges
-rgit review              # list proposals
-rgit review --approve <proposal_id> --name rerank-retrieval
-```
+`rgit capture` saves the current changes (or the last commit) when you're not using `rgit run`. Bringing an idea *back* needs an agent session — that's where the intelligence lives; from the terminal you can always browse the memory with `rgit features` and `rgit graph`.
 
-Committed before capturing? Just run `rgit capture` — on a clean tree it captures the last commit (and says which one); `rgit capture main..HEAD` takes a whole span. (With the optional post-commit hook installed, every commit stages itself automatically.)
+More commands as your store grows: [More commands](#more-commands).
 
-### 4. Bring an idea back onto today's code
+---
 
-Weeks later, after the agent has moved on:
+## Updating
 
-```
-/rgit-recall  bring back the re-ranking retrieval step
+```bash
+rgit update
 ```
 
-Recall scores capsules against your query, surfaces each hit with its related neighbors, then dispatches a subagent that *re-implements* the idea onto today's structure — adapting to refactors and leaving you a reviewable diff.
+Upgrades the package (via whichever of uv/pipx/pip installed it) and refreshes every installed platform surface: the Claude Code plugin copy, MCP config, and the managed guidance blocks. Guidance blocks you have customized or removed are left alone — the command tells you how to restore them instead.
 
-That's the whole loop. The rest of the commands you'll meet as you need them — see [More commands](#more-commands).
+rgit checks PyPI for a newer release at most once a day (in the background, terminal sessions only). Once one is found, it prints a one-line upgrade notice after every qualifying command until you upgrade or turn the notice off — the check is throttled, the reminder is not. Silence it for good with `rgit update --off`, or per-environment with `RGIT_UPDATE_CHECK=0`.
 
 ---
 
@@ -207,7 +200,7 @@ The five-step loop above is the core. These show up as your store grows — run
 |---------|--------------|
 | `rgit watch` | free, deterministic background capture — stages raw material as you edit, so fleeting in-between states aren't lost |
 | `rgit capture [REV \| A..B]` | bare: auto-picks the working tree or, when clean, the last commit; pass a commit or an A..B range for precise control |
-| `rgit install-hooks` | opt-in: stage every commit's diff via a post-commit hook (not installed by `rgit install`; won't touch an existing hook) — see step 2 above |
+| `rgit install-hooks` | opt-in: stage every commit's diff via a post-commit hook (not installed by `rgit install`; won't touch an existing hook) — see install details above |
 | `rgit run --from <capsule>` | run a recalled variant and link the new run as a `variant_of` the original |
 | `rgit compare <query>` | which variant won: ranked table, Δ vs baseline, ★ winner |
 | `rgit provenance <run_id>` | per-feature clean (capsule) vs agent-adapted (frozen) diff for a run |

{research_git-0.0.4 → research_git-0.0.6}/README.md

@@ -68,65 +68,58 @@ Capsules live in a small graph beside your repo (`.rgit/`), on top of normal git
 
 ## 🚀 Quick Start
 
-Five steps: install → init → run → capture → recall.
-
 ### 1. Install
 
 ```bash
-pip install research-git        # or, from a clone: pip install -e .
-
-# wire the plugin (agents + skills) and the MCP server into your client
-rgit install                    # auto-detects every agent client on this machine and wires them all
-rgit install claude-code        # or pick one explicitly (claude-code / codex / gemini / opencode / generic)
-rgit install --list             # list platforms; --uninstall to remove
+pip install research-git
+rgit install        # wires research-git into every agent client on this machine
+cd your-project
+rgit init           # creates the .rgit/ store in your repo
 ```
 
-`codex`, `gemini`, and `opencode` share the `~/.agents/skills/` convention — the installer symlinks each skill there and prints the one-line MCP server entry to drop into that client's config. It also writes a managed research-git guidance block into the client's global guidance file when the platform has one (`~/.codex/AGENTS.md`, `~/.claude/CLAUDE.md`, or `~/.gemini/GEMINI.md`). On an interactive terminal you're asked how proactive capture should be — `default`, `manual-only`, or `none`; pass `--guidance <mode>` to choose non-interactively. Start a new agent session after install so the guidance is loaded. Prefer the manual route on Claude Code? `/plugin marketplace add StepzeroLab/research-git` then `/plugin install research-git@research-git`.
+That's the whole setup. Start a new agent session afterwards so it picks everything up.
 
-### 2. Initialize in your repo
+<details>
+<summary>Install details: choosing platforms, guidance modes, capture-on-commit</summary>
 
-```bash
-cd your-project
-rgit init                       # creates .rgit/ (the store) at the git root
-```
+- `rgit install claude-code` (or `codex` / `gemini` / `opencode` / `generic`) targets one client; `--list` shows all; `--uninstall` removes.
+- The installer also writes a short guidance block into your client's global file (`~/.claude/CLAUDE.md`, `~/.codex/AGENTS.md`, …) so the agent knows when to save ideas. On an interactive terminal you pick how proactive that should be (`default` / `manual-only` / `none`); pass `--guidance <mode>` to choose non-interactively.
+- **Optional:** `rgit install-hooks` (per repo) makes every `git commit` stage its own snapshot automatically, so nothing slips through even when you forget. It never touches an existing hook, hooks never approve anything, and `rgit install-hooks --uninstall` removes it. Skip it in CI or shared clones.
+- Manual route on Claude Code: `/plugin marketplace add StepzeroLab/research-git` then `/plugin install research-git@research-git`.
 
-**Optional — capture on every commit.** `rgit install <platform>` wires the agent side only; it deliberately does **not** touch your git hooks. If you also want every `git commit` to stage its own diff as a pending proposal automatically, opt in with:
+</details>
 
-```bash
-rgit install-hooks              # adds a post-commit hook (never clobbers an existing one)
-```
+### 2. Working with an agent? Just talk to it
 
-Good fit: solo research repos where you want nothing to slip through, even when you forget to capture. Skip it if the repo already has its own post-commit hook (the installer refuses to touch foreign hooks, so nothing breaks — it just won't install), if your team prefers deliberate manual capture, or in CI/shared clones where commit-time side effects are unwelcome. Without hooks you lose nothing: bare `rgit capture` takes the last commit when the tree is clean, `rgit capture A..B` a whole span, and `rgit review` is the gate either way — hooks only stage proposals, they never approve anything. Remove with `rgit install-hooks --uninstall`.
+After install your agent does the remembering. Work as usual — it saves each meaningful idea as a Feature Capsule (asking you before anything is kept). Weeks later, when the code has moved on, just ask:
 
-### 3. Run a variation and capture the idea
+> *"bring back the re-ranking retrieval step"*
 
-Launch your work through `rgit run` — it executes your command, freezes a reproducible artifact, records the run + any metrics, and stages what changed:
+The agent finds the capsule and **re-implements the idea onto today's code**, leaving you a reviewable diff. No commands to memorize — but if you like being explicit, `/rgit-capture` saves recent work and `/rgit-recall <what you want back>` brings an idea home.
+
+### 3. Working in the terminal? Three commands
 
 ```bash
-rgit run -- python eval_agent.py --retrieval rerank
+rgit run -- python eval_agent.py --retrieval rerank   # run an experiment; freezes a byte-exact snapshot + metrics
+rgit review                                           # see what's been captured, approve what's worth keeping
+rgit compare rerank                                   # which variant won?
 ```
 
-Then turn that raw material into a clean capsule (in a Claude Code session):
-
-```
-/rgit-capture            # segments the diff into Feature Capsules, then wires up graph edges
-rgit review              # list proposals
-rgit review --approve <proposal_id> --name rerank-retrieval
-```
+`rgit capture` saves the current changes (or the last commit) when you're not using `rgit run`. Bringing an idea *back* needs an agent session — that's where the intelligence lives; from the terminal you can always browse the memory with `rgit features` and `rgit graph`.
 
-Committed before capturing? Just run `rgit capture` — on a clean tree it captures the last commit (and says which one); `rgit capture main..HEAD` takes a whole span. (With the optional post-commit hook installed, every commit stages itself automatically.)
+More commands as your store grows: [More commands](#more-commands).
 
-### 4. Bring an idea back onto today's code
+---
 
-Weeks later, after the agent has moved on:
+## Updating
 
-```
-/rgit-recall  bring back the re-ranking retrieval step
+```bash
+rgit update
 ```
 
-Recall scores capsules against your query, surfaces each hit with its related neighbors, then dispatches a subagent that *re-implements* the idea onto today's structure — adapting to refactors and leaving you a reviewable diff.
+Upgrades the package (via whichever of uv/pipx/pip installed it) and refreshes every installed platform surface: the Claude Code plugin copy, MCP config, and the managed guidance blocks. Guidance blocks you have customized or removed are left alone — the command tells you how to restore them instead.
 
-That's the whole loop. The rest of the commands you'll meet as you need them — see [More commands](#more-commands).
+rgit checks PyPI for a newer release at most once a day (in the background, terminal sessions only). Once one is found, it prints a one-line upgrade notice after every qualifying command until you upgrade or turn the notice off — the check is throttled, the reminder is not. Silence it for good with `rgit update --off`, or per-environment with `RGIT_UPDATE_CHECK=0`.
 
 ---
 
@@ -181,7 +174,7 @@ The five-step loop above is the core. These show up as your store grows — run
 |---------|--------------|
 | `rgit watch` | free, deterministic background capture — stages raw material as you edit, so fleeting in-between states aren't lost |
 | `rgit capture [REV \| A..B]` | bare: auto-picks the working tree or, when clean, the last commit; pass a commit or an A..B range for precise control |
-| `rgit install-hooks` | opt-in: stage every commit's diff via a post-commit hook (not installed by `rgit install`; won't touch an existing hook) — see step 2 above |
+| `rgit install-hooks` | opt-in: stage every commit's diff via a post-commit hook (not installed by `rgit install`; won't touch an existing hook) — see install details above |
 | `rgit run --from <capsule>` | run a recalled variant and link the new run as a `variant_of` the original |
 | `rgit compare <query>` | which variant won: ranked table, Δ vs baseline, ★ winner |
 | `rgit provenance <run_id>` | per-feature clean (capsule) vs agent-adapted (frozen) diff for a run |

{research_git-0.0.4 → research_git-0.0.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "research-git"
-version = "0.0.4"
+version = "0.0.6"
 description = "A memory system that captures code ideas as semantic capsules you can regenerate onto today's codebase"
 readme = "README.md"
 license = "MIT"

{research_git-0.0.4 → research_git-0.0.6/src/research_git.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: research-git
-Version: 0.0.4
+Version: 0.0.6
 Summary: A memory system that captures code ideas as semantic capsules you can regenerate onto today's codebase
 Author: Stepzero Lab
 License-Expression: MIT
@@ -94,65 +94,58 @@ Capsules live in a small graph beside your repo (`.rgit/`), on top of normal git
 
 ## 🚀 Quick Start
 
-Five steps: install → init → run → capture → recall.
-
 ### 1. Install
 
 ```bash
-pip install research-git        # or, from a clone: pip install -e .
-
-# wire the plugin (agents + skills) and the MCP server into your client
-rgit install                    # auto-detects every agent client on this machine and wires them all
-rgit install claude-code        # or pick one explicitly (claude-code / codex / gemini / opencode / generic)
-rgit install --list             # list platforms; --uninstall to remove
+pip install research-git
+rgit install        # wires research-git into every agent client on this machine
+cd your-project
+rgit init           # creates the .rgit/ store in your repo
 ```
 
-`codex`, `gemini`, and `opencode` share the `~/.agents/skills/` convention — the installer symlinks each skill there and prints the one-line MCP server entry to drop into that client's config. It also writes a managed research-git guidance block into the client's global guidance file when the platform has one (`~/.codex/AGENTS.md`, `~/.claude/CLAUDE.md`, or `~/.gemini/GEMINI.md`). On an interactive terminal you're asked how proactive capture should be — `default`, `manual-only`, or `none`; pass `--guidance <mode>` to choose non-interactively. Start a new agent session after install so the guidance is loaded. Prefer the manual route on Claude Code? `/plugin marketplace add StepzeroLab/research-git` then `/plugin install research-git@research-git`.
+That's the whole setup. Start a new agent session afterwards so it picks everything up.
 
-### 2. Initialize in your repo
+<details>
+<summary>Install details: choosing platforms, guidance modes, capture-on-commit</summary>
 
-```bash
-cd your-project
-rgit init                       # creates .rgit/ (the store) at the git root
-```
+- `rgit install claude-code` (or `codex` / `gemini` / `opencode` / `generic`) targets one client; `--list` shows all; `--uninstall` removes.
+- The installer also writes a short guidance block into your client's global file (`~/.claude/CLAUDE.md`, `~/.codex/AGENTS.md`, …) so the agent knows when to save ideas. On an interactive terminal you pick how proactive that should be (`default` / `manual-only` / `none`); pass `--guidance <mode>` to choose non-interactively.
+- **Optional:** `rgit install-hooks` (per repo) makes every `git commit` stage its own snapshot automatically, so nothing slips through even when you forget. It never touches an existing hook, hooks never approve anything, and `rgit install-hooks --uninstall` removes it. Skip it in CI or shared clones.
+- Manual route on Claude Code: `/plugin marketplace add StepzeroLab/research-git` then `/plugin install research-git@research-git`.
 
-**Optional — capture on every commit.** `rgit install <platform>` wires the agent side only; it deliberately does **not** touch your git hooks. If you also want every `git commit` to stage its own diff as a pending proposal automatically, opt in with:
+</details>
 
-```bash
-rgit install-hooks              # adds a post-commit hook (never clobbers an existing one)
-```
+### 2. Working with an agent? Just talk to it
 
-Good fit: solo research repos where you want nothing to slip through, even when you forget to capture. Skip it if the repo already has its own post-commit hook (the installer refuses to touch foreign hooks, so nothing breaks — it just won't install), if your team prefers deliberate manual capture, or in CI/shared clones where commit-time side effects are unwelcome. Without hooks you lose nothing: bare `rgit capture` takes the last commit when the tree is clean, `rgit capture A..B` a whole span, and `rgit review` is the gate either way — hooks only stage proposals, they never approve anything. Remove with `rgit install-hooks --uninstall`.
+After install your agent does the remembering. Work as usual — it saves each meaningful idea as a Feature Capsule (asking you before anything is kept). Weeks later, when the code has moved on, just ask:
 
-### 3. Run a variation and capture the idea
+> *"bring back the re-ranking retrieval step"*
 
-Launch your work through `rgit run` — it executes your command, freezes a reproducible artifact, records the run + any metrics, and stages what changed:
+The agent finds the capsule and **re-implements the idea onto today's code**, leaving you a reviewable diff. No commands to memorize — but if you like being explicit, `/rgit-capture` saves recent work and `/rgit-recall <what you want back>` brings an idea home.
+
+### 3. Working in the terminal? Three commands
 
 ```bash
-rgit run -- python eval_agent.py --retrieval rerank
+rgit run -- python eval_agent.py --retrieval rerank   # run an experiment; freezes a byte-exact snapshot + metrics
+rgit review                                           # see what's been captured, approve what's worth keeping
+rgit compare rerank                                   # which variant won?
 ```
 
-Then turn that raw material into a clean capsule (in a Claude Code session):
-
-```
-/rgit-capture            # segments the diff into Feature Capsules, then wires up graph edges
-rgit review              # list proposals
-rgit review --approve <proposal_id> --name rerank-retrieval
-```
+`rgit capture` saves the current changes (or the last commit) when you're not using `rgit run`. Bringing an idea *back* needs an agent session — that's where the intelligence lives; from the terminal you can always browse the memory with `rgit features` and `rgit graph`.
 
-Committed before capturing? Just run `rgit capture` — on a clean tree it captures the last commit (and says which one); `rgit capture main..HEAD` takes a whole span. (With the optional post-commit hook installed, every commit stages itself automatically.)
+More commands as your store grows: [More commands](#more-commands).
 
-### 4. Bring an idea back onto today's code
+---
 
-Weeks later, after the agent has moved on:
+## Updating
 
-```
-/rgit-recall  bring back the re-ranking retrieval step
+```bash
+rgit update
 ```
 
-Recall scores capsules against your query, surfaces each hit with its related neighbors, then dispatches a subagent that *re-implements* the idea onto today's structure — adapting to refactors and leaving you a reviewable diff.
+Upgrades the package (via whichever of uv/pipx/pip installed it) and refreshes every installed platform surface: the Claude Code plugin copy, MCP config, and the managed guidance blocks. Guidance blocks you have customized or removed are left alone — the command tells you how to restore them instead.
 
-That's the whole loop. The rest of the commands you'll meet as you need them — see [More commands](#more-commands).
+rgit checks PyPI for a newer release at most once a day (in the background, terminal sessions only). Once one is found, it prints a one-line upgrade notice after every qualifying command until you upgrade or turn the notice off — the check is throttled, the reminder is not. Silence it for good with `rgit update --off`, or per-environment with `RGIT_UPDATE_CHECK=0`.
 
 ---
 
@@ -207,7 +200,7 @@ The five-step loop above is the core. These show up as your store grows — run
 |---------|--------------|
 | `rgit watch` | free, deterministic background capture — stages raw material as you edit, so fleeting in-between states aren't lost |
 | `rgit capture [REV \| A..B]` | bare: auto-picks the working tree or, when clean, the last commit; pass a commit or an A..B range for precise control |
-| `rgit install-hooks` | opt-in: stage every commit's diff via a post-commit hook (not installed by `rgit install`; won't touch an existing hook) — see step 2 above |
+| `rgit install-hooks` | opt-in: stage every commit's diff via a post-commit hook (not installed by `rgit install`; won't touch an existing hook) — see install details above |
 | `rgit run --from <capsule>` | run a recalled variant and link the new run as a `variant_of` the original |
 | `rgit compare <query>` | which variant won: ranked table, Δ vs baseline, ★ winner |
 | `rgit provenance <run_id>` | per-feature clean (capsule) vs agent-adapted (frozen) diff for a run |

{research_git-0.0.4 → research_git-0.0.6}/src/research_git.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ src/research_git.egg-info/entry_points.txt
 src/research_git.egg-info/requires.txt
 src/research_git.egg-info/top_level.txt
 src/rgit/__init__.py
+src/rgit/__main__.py
 src/rgit/ablation.py
 src/rgit/agent_guidance.py
 src/rgit/agent_platforms.py
@@ -16,6 +17,7 @@ src/rgit/cli.py
 src/rgit/compare.py
 src/rgit/compose.py
 src/rgit/curation.py
+src/rgit/doctor.py
 src/rgit/edges.py
 src/rgit/gitutil.py
 src/rgit/graphview.py
@@ -29,8 +31,10 @@ src/rgit/ranking.py
 src/rgit/recall.py
 src/rgit/runner.py
 src/rgit/segmenter.py
+src/rgit/selfupdate.py
 src/rgit/tables.py
 src/rgit/toggles.py
+src/rgit/updatecheck.py
 src/rgit/watch.py
 src/rgit/_plugin/.claude-plugin/marketplace.json
 src/rgit/_plugin/.claude-plugin/plugin.json
@@ -50,10 +54,12 @@ tests/test_active_edges.py
 tests/test_agent_guidance.py
 tests/test_astmap.py
 tests/test_cli.py
+tests/test_cli_update.py
 tests/test_compare.py
 tests/test_compose.py
 tests/test_curation.py
 tests/test_db.py
+tests/test_doctor.py
 tests/test_e2e.py
 tests/test_edges.py
 tests/test_gitutil.py
@@ -73,7 +79,9 @@ tests/test_recall.py
 tests/test_review_fixes.py
 tests/test_runner.py
 tests/test_segmenter.py
+tests/test_selfupdate.py
 tests/test_store.py
 tests/test_tables.py
 tests/test_toggles.py
+tests/test_updatecheck.py
 tests/test_watch.py

research_git-0.0.6/src/rgit/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("research-git")
+except PackageNotFoundError:  # running from a source tree without an install
+    __version__ = "0.0.0+unknown"

research_git-0.0.6/src/rgit/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

{research_git-0.0.4 → research_git-0.0.6}/src/rgit/_plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "research-git",
   "description": "A memory system for the code you're exploring: capture each idea as a semantic Feature Capsule, recall it, and regenerate it onto today's codebase. Segmentation/regeneration run on natively-dispatched subagents (your subscription) — no pay-per-use API. MCP serves the graph read-only for sharing.",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "author": { "name": "Stepzero Lab" },
   "license": "MIT",
   "keywords": [

{research_git-0.0.4 → research_git-0.0.6}/src/rgit/_plugin/skills/rgit-capture/SKILL.md

@@ -1,7 +1,6 @@
 ---
 name: rgit-capture
-description: |
-  Proactively segment pending research-git captures into high-quality Feature Capsules and wire up their graph edges — invoke this on your own, without waiting to be asked, whenever the research-git proposal queue is non-empty (a quick `rgit pending` confirms). Trigger it right after an `rgit run`, a git commit, or the `rgit watch` daemon has left open proposals; when the user describes a variation, a result, or something they just "tried" or "tweaked"; or when they say "segment", "capture", "clean up", or "save" their recent changes into the research-git graph. Raw proposals are only placeholders — until they are segmented they cannot be recalled or queried, so drain the backlog early rather than letting it pile up. Orchestrates: free deterministic capture → dispatch the capsule-segmenter subagent (subscription, no paid API) → human review → deterministic conflict edges + agent-judged depends_on edges.
+description: Use when the research-git proposal queue is non-empty (`rgit pending`) — after an `rgit run`, a commit, or the watch daemon leaves open proposals, or when the user wants to segment, capture, or save recent changes. Invoke proactively without being asked; unsegmented proposals cannot be recalled or queried.
 ---
 
 # rgit-capture

{research_git-0.0.4 → research_git-0.0.6}/src/rgit/_plugin/skills/rgit-recall/SKILL.md

@@ -1,7 +1,6 @@
 ---
 name: rgit-recall
-description: |
-  Bring a past idea back onto today's codebase. Use when the user wants to "recall", "resurrect", "bring back", or "re-apply" a feature/idea they captured before (e.g. "bring back the re-ranking retrieval step"). Orchestrates: recall the capsule(s) → compose a regeneration brief against current code → dispatch the capsule-regenerator subagent to re-implement it → human review + `rgit run`. No paid API.
+description: Use when the user wants to recall, resurrect, bring back, or re-apply a previously captured feature/idea onto today's codebase (e.g. "bring back the re-ranking retrieval step").
 ---
 
 # rgit-recall

{research_git-0.0.4 → research_git-0.0.6}/src/rgit/agent_guidance.py

@@ -1,6 +1,7 @@
 """Managed global guidance block for agent clients."""
 from __future__ import annotations
 
+import hashlib
 import os
 import re
 from pathlib import Path
@@ -14,12 +15,34 @@ END = "<!-- research-git:end -->"
 KNOWN_MODES = ("default", "manual-only", "custom")
 _MODE_RE = re.compile(r"^Current mode:[ \t]*(.+)$", re.MULTILINE)
 
+# Fingerprinted START marker: h= is the canonical hash of the block body, so
+# the update path can tell an official block (safe to replace) from one the
+# user edited (never touch). The bare `START` form is what pre-0.0.5 releases
+# wrote; _START_RE accepts both.
+_START_RE = re.compile(r"<!-- research-git:start(?: h=([0-9a-f]{12}))? -->")
+
+# canonical_hash of every official block body ever shipped without a
+# fingerprint (see docs/superpowers/specs/2026-07-04-runtime-update-check-design.md).
+HISTORICAL_HASHES = frozenset({
+    "9e20fa27047f",   # v0.0.1 - v0.0.3
+    "c7d73fc2ba60",   # v0.0.4
+})
+
+
+def canonical_hash(block: str) -> str:
+    """12-hex digest of a block's body: markers and mode line excluded, so the
+    hash survives mode pinning and marker-format changes."""
+    lines = block.strip().splitlines()
+    body = [l.rstrip() for l in lines[1:-1]
+            if not l.startswith("Current mode:")]
+    text = "\n".join(body).strip() + "\n"
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()[:12]
+
 
 def render_global_block(mode: str = "default") -> str:
     if mode not in KNOWN_MODES:
         mode = "default"
-    return (
-        f"{START}\n"
+    body = (
         "## research-git\n"
         "\n"
         "research-git is installed as a default agent capability.\n"
@@ -63,8 +86,10 @@ def render_global_block(mode: str = "default") -> str:
         "silently.\n"
         "- In final feedback, mention any capsules created, approved, applied, "
         "or skipped, plus important graph relations.\n"
-        f"{END}\n"
     )
+    provisional = f"{START}\n{body}{END}\n"
+    h = canonical_hash(provisional)
+    return f"<!-- research-git:start h={h} -->\n{body}{END}\n"
 
 
 def manual_status(mode: str = "default") -> dict:
@@ -149,16 +174,70 @@ def _carry_mode(old_block: str, new_block: str) -> str:
 
 
 def _managed_span(text: str) -> tuple[int, int] | None:
-    start = text.find(START)
-    if start < 0:
+    m = _START_RE.search(text)
+    if m is None:
         return None
-    end = text.find(END, start)
+    end = text.find(END, m.start())
     if end < 0:
         return None
     after_end = end + len(END)
     if text[after_end:after_end + 1] == "\n":
         after_end += 1
-    return start, after_end
+    return m.start(), after_end
+
+
+def classify_block(text: str) -> str:
+    """absent | broken | pristine | customized (update-path policy input)."""
+    span = _managed_span(text)
+    if span is None:
+        if _START_RE.search(text) or END in text:
+            return "broken"
+        return "absent"
+    block = text[span[0]:span[1]]
+    h = canonical_hash(block)
+    stamped = _START_RE.match(block).group(1)
+    if h == stamped or h in HISTORICAL_HASHES \
+            or h == canonical_hash(render_global_block()):
+        return "pristine"
+    return "customized"
+
+
+def refresh_managed_block(path: Path, *, dry_run: bool = False) -> dict:
+    """Update-path guidance refresh: replace only pristine official blocks.
+
+    Unlike upsert_managed_block (explicit-install semantics), this never
+    appends a missing block and never overwrites user edits - it skips and
+    explains instead. `dry_run` short-circuits the only writing path (a
+    pending update to a pristine block) and reports `would_update` instead;
+    the skip/absent branches are already read-only.
+    """
+    if not path.exists():
+        return {"action": "absent_file", "path": str(path)}
+    text = path.read_text(encoding="utf-8")
+    kind = classify_block(text)
+    if kind == "absent":
+        return {"action": "skipped_removed", "path": str(path),
+                "hint": (f"no research-git block in {path} (removed on "
+                         f"purpose?) — run `rgit install` to restore it")}
+    if kind == "broken":
+        return {"action": "skipped_broken", "path": str(path),
+                "hint": (f"research-git markers in {path} look damaged (one "
+                         f"of the start/end pair is missing) — fix or remove "
+                         f"them manually, then run `rgit install`")}
+    if kind == "customized":
+        return {"action": "skipped_customized", "path": str(path),
+                "hint": (f"customized research-git block in {path} left "
+                         f"untouched — run `rgit install` to overwrite it "
+                         f"with the new official version")}
+    start, end = _managed_span(text)
+    block = _carry_mode(text[start:end], render_global_block("default"))
+    new_text = text[:start] + block + text[end:]
+    if new_text == text:
+        return {"action": "unchanged", "path": str(path)}
+    if dry_run:
+        return {"action": "would_update", "path": str(path)}
+    _atomic_write(path, new_text)
+    return {"action": "updated", "path": str(path)}
 
 
 def _dry_action(action: str) -> str: