diff --git a/README.md b/README.md index b9db8d4..443c67a 100644 --- a/README.md +++ b/README.md @@ -1,83 +1,50 @@ -

research-git

+

research-git logo   research-git

- A new Git tool for ambitious researchers and developers in the agentic era. + Reapply or remove previous experiments & features safely on today’s code.
Works with Claude Code, Codex, Gemini CLI, and opencode.

- Quick Start + Quick Start License: MIT - Claude Code + Claude Code + Codex Python 3.11+

- A Git tool for ambitious researchers and developers in the agentic era. + research-git capture and removal workflow in Codex

-Git remembers commits. research-git remembers ideas. +research-git is a new Git tool for researchers and developers, built for the agentic coding era. -research-git turns experiments and features into reusable **Feature Capsules** so coding agents can reapply, adapt, or remove them safely as your code evolves. +It captures important experiments and feature decisions as reusable semantic units, links experimental results to the code that produced them, and helps coding agents reapply, adapt, or safely remove earlier ideas on today’s codebase. -> **Not a rollback. Not hard deletion. Bring back the idea, not the old branch.** +## Why research-git ---- +AI coding tools can generate many different experiments and features in a day. But when you try to reintroduce a previously removed experiment just a few days later, the codebase may have changed so much that the experiment no longer fits the current infrastructure. -## How it works - -One loop: capture each idea into a graph, then regenerate it onto today's code. The engine (blue) is free and deterministic; intelligence happens at exactly two points (green) — subagents dispatched onto your existing subscription, never a paid API. - -```mermaid -flowchart LR - A["edit code /
rgit run -- ..."] -->|"free, deterministic"| B["raw proposal
(diff staged)"] - B -->|"/rgit-capture"| C{{"capsule-
segmenter"}} - C --> D[("Feature Capsule
graph (.rgit/)")] - D -->|"/rgit-recall «query»"| E["compose brief vs
today's code"] - E --> F{{"capsule-
regenerator"}} - F --> G["reviewable diff
on today's code"] - G -.->|"rgit run — freeze + link variant"| D - - classDef engine fill:#eef2ff,stroke:#5b6cff,color:#1e2a78; - classDef agent fill:#eafff0,stroke:#36a85f,color:#0f5132; - class A,B,D,E,G engine; - class C,F agent; -``` - ---- +Traditional Git preserves commits and diffs, but it does not preserve the context behind them. It cannot tell an agent which changes belong to an experiment, why they were made, what assumptions they depended on, or what results they produced. Without that context, reverting may erase later work, replaying an old diff may fail against a changed architecture, and removing a feature may damage shared infrastructure. -## The Feature Capsule +research-git records experiments and feature decisions as reusable Capsules, capturing their intent, relevant code, dependencies, configuration, and restoration guidance. It also links experimental results to the exact code that produced them. This gives coding agents the context to safely reapply or remove earlier ideas on today’s codebase without restoring an old snapshot or deleting code piece by piece. -Every idea you keep becomes one capsule — a self-contained unit a future agent can read and bring back: +## Quick Start -| Field | What it holds | -|-------|---------------| -| **intent** | why this change existed — the hypothesis, not a diff restatement | -| **code slices** | the relevant snippets / files / symbols | -| **knobs** | parameters / flags / configs | -| **dependencies** | other capsules it needs + silent assumptions | -| **result** | metrics / notes / why it worked or didn't, linked to the runs it produced | -| **resurrection guide** | how to regenerate it onto a changed codebase | - -Capsules live in a small graph beside your repo (`.rgit/`), on top of normal git. Every run you launch through research-git also freezes a **byte-exact, content-addressed snapshot** of the code that ran — so "the code behind this result" is always a perfect replay, never at the mercy of an agent. - ---- - -## 🚀 Quick Start +> [!NOTE] +> We publish a new research-git release after major iterations. [Keep research-git updated](#updating). ### 1. Install ```bash pip install research-git -rgit install # wires research-git into every agent client on this machine +rgit install # wires research-git into every agent client on this machine cd your-project -rgit init # creates the .rgit/ store in your repo +rgit init # creates the .rgit/ store in your repo ``` -That's the whole setup. Start a new agent session afterwards so it picks everything up. - -Adopting rgit on a repo that already has history? `rgit init` offers to **digest that history into capsules** — pick a mode in the prompt, then let your agent run the `rgit-digest` skill so recall has something to find from day one. +Installation takes less than 30 seconds. Restart your coding agent afterwards so it loads research-git.
Install details: choosing platforms, guidance modes, capture-on-commit @@ -91,11 +58,29 @@ Adopting rgit on a repo that already has history? `rgit init` offers to **digest ### 2. Working with an agent? Just talk to it -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: +If your repository already has history, let your agent run the `rgit-digest` skill. It turns earlier work into Capsules, giving recall something to find from day one. -> *"bring back the re-ranking retrieval step"* +

+ Agent prompt: @research-git:rgit-digest Digest this repository's history. +

+ +After install your agent does the remembering. Work as usual. It saves each meaningful idea as a Feature Capsule and asks you before anything is kept. Weeks later, when the code has moved on, just ask: + +

+ Agent prompt: Bring back the re-ranking retrieval step. +

-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 ` brings an idea home. +The agent finds the capsule and **re-implements the idea onto today's code**, leaving you a reviewable diff. There are no commands to memorize. If you like being explicit, `/rgit-capture` saves recent work and `/rgit-recall ` brings an idea home. + +

+ Agent prompt: @research-git:rgit-recall Bring back the re-ranking retrieval step. +

+ +After the idea is brought back, ask your agent to run its evaluation with research-git. The Run keeps the exact code snapshot and metrics together. If the implementation includes code changes, research-git also stages them as a Capsule Proposal for you to decide whether to keep. + +

+ Agent prompt: The re-ranking step is ready. Run its evaluation and record the results with research-git. +

### 3. Working in the terminal? Three commands @@ -105,47 +90,47 @@ rgit review # see what's been captured rgit compare rerank # which variant won? ``` -`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`. +`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 because that's where the intelligence lives. From the terminal, you can always browse the memory with `rgit features` and `rgit graph`. More commands as your store grows: [More commands](#more-commands). ---- +## Where it fits -## Updating +Anywhere you try many variations of one thing and later want to bring one back or safely remove one from today's codebase. -```bash -rgit update -``` - -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. - -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`. - ---- +- **Agent / Prompt engineering:** You tried four prompt structures, two tool-splitting schemes, and a different retrieval step. Last week's version scored better; bring *that* idea back onto the agent you've since rewritten. +- **Backend / Systems:** Three caching strategies, two rate-limiters, a reworked query plan. Which won? Pull the winning variant forward without reverting everything built since. +- **Frontend:** Competing interaction flows and layout variants, half commented out. Resurrect the one that tested best onto the current component tree. +- **ML research:** Different loss terms, attention blocks, and augmentations. The experiment is the idea, the metrics are the result, and you want one variant back on today's code. -## 🧩 Where it fits - -Anywhere you try many variations of one thing and later want a single one back — cleanly, on top of how the code looks now. +## How it works -- 🤖 **Agent / Prompt engineering** — you tried four prompt structures, two tool-splitting schemes, and a different retrieval step. Last week's version scored better; bring *that* idea back onto the agent you've since rewritten. -- ⚙️ **Backend / Systems** — three caching strategies, two rate-limiters, a reworked query plan. Which won? Pull the winning variant forward without reverting everything built since. -- 🎨 **Frontend** — competing interaction flows and layout variants, half commented out. Resurrect the one that tested best onto the current component tree. +Figure 1 shows how code changes become Capsules. After you edit code or complete an `rgit run`, research-git's local engine reads the Git diff, maps changed hunks to code symbols, stores the captured change, and stages a raw Proposal. This processing is deterministic and does not call a model or API. The experiment executed by `rgit run` still uses whatever compute it requires. -Also at home in ML research — different loss terms, attention blocks, augmentations. Same shape: the experiment is the idea, the metrics are the result, and you want one variant back on today's code. +The agentic phase begins with the `/rgit-capture` skill. In the default mode, your coding agent starts this flow automatically after meaningful changes; you can also invoke the skill explicitly. A `capsule-segmenter` sub-agent turns the raw Proposal into focused Capsule candidates and asks which ones you want to keep. After approval, an `edge-judge` sub-agent identifies relationships with the existing graph. These sub-agents run on your existing coding-agent subscription without using a paid API. ---- +

+ research-git Capsule capture workflow +
+ Figure 1. Capturing code changes into the Capsule graph. +

-## 🤝 Share the memory with your team +Figure 2 shows how a stored Capsule is used on today's code. The `/rgit-recall` skill searches the graph and retrieves the relevant intent, code context, assumptions, dependencies, and restoration guidance. A coding agent uses this context to reapply or remove the idea against the current code, leaving a reviewable diff instead of restoring an old snapshot or replaying an outdated patch. -The graph is served over MCP **read-only** (`recall` / `compose` / `get`, plus the query commands `compare` / `ablation` / `provenance`). Point a teammate's client at your `rgit mcp` server and they get the same Feature Capsules and the same answers — then *their* session regenerates an idea onto *their* code, on *their* subscription. The memory is shared; the intelligence is local. +After you review the diff, `rgit run` can evaluate the implementation, freeze the exact code that ran, and record its metrics. If the resulting Proposal is approved, the new Capsule is linked to the recalled Capsule as a variant. `rgit run` records the result and lineage; it does not perform recall or create the variant before approval. ---- +

+ research-git Capsule recall workflow +
+ Figure 2. Recalling Capsules and recording new variants. +

-## 🔧 Under the Hood +
+Learn more (under the hood) ### Build the memory, borrow the agent -The engine owns the durable, deterministic parts — the graph, content-addressed object store, git diffing, and the byte-exact run freeze. The agentic parts are delegated to subagents the host already provides. We don't reimplement an agent loop, and we never call a paid API. +The engine owns the durable, deterministic parts: the graph, content-addressed object store, git diffing, and the byte-exact run freeze. The agentic parts are delegated to subagents the host already provides. We don't reimplement an agent loop, and we never call a paid API. ### Two-phase capture @@ -153,40 +138,148 @@ A free, deterministic Phase 1 (`libcst` maps diff hunks to the functions/classes ### Ranked, edge-aware recall -Recall scores every approved capsule against your query in plain Python — no embeddings, no SQL `LIKE` traps — and boosts a hit when a connected capsule also matches, so related work surfaces together. Each result carries its related subgraph. +Recall scores every approved capsule against your query in plain Python, without embeddings or SQL `LIKE` traps. It boosts a hit when a connected capsule also matches, so related work surfaces together. Each result carries its related subgraph. ### Two planes -- **MCP — shared memory (query-only).** Returns graph snippets; safe to expose so a team shares one memory. Carries no intelligence. -- **Plugin — local intelligence.** Three subagents (`capsule-segmenter`, `capsule-regenerator`, `edge-judge`) and two skills (`rgit-capture`, `rgit-recall`) define *how* a session acts on those snippets, natively, on its own subscription. +- **MCP: shared memory (query-only).** Returns graph snippets; safe to expose so a team shares one memory. Carries no intelligence. +- **Plugin: local intelligence.** Three subagents (`capsule-segmenter`, `capsule-regenerator`, `edge-judge`) and two skills (`rgit-capture`, `rgit-recall`) define *how* a session acts on those snippets, natively, on its own subscription. ### Reproducibility contract The agent helps you *author*; it is never in the *replay* path. `rgit run` freezes the exact bytes that ran, content-addressed and immutable. "The code behind run X" is a byte-identical re-materialization of a stored blob. ---- +
-## More commands +## What a Capsule Contains + +Every idea you keep becomes a self-contained Capsule that a future agent can use to bring the idea back: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FieldWhat it holds
intentWhy this change existed: the hypothesis, not a restatement of the diff.
code slicesThe relevant snippets, files, and symbols.
knobsThe parameters, flags, and configuration.
dependenciesThe other Capsules it needs, including silent assumptions.
resultThe metrics, notes, and reasons it worked or did not work, linked to the runs it produced.
resurrection guideHow to regenerate it onto a changed codebase.
+ +Capsules live in a small graph beside your repo (`.rgit/`), on top of normal git. Every run you launch through research-git also freezes a **byte-exact, content-addressed snapshot** of the code that ran. This ensures "the code behind this result" is always a perfect replay, never at the mercy of an agent. + +## Additional Capabilities + +### 1. Run Experiments and Record Results + +```bash +rgit run -- python eval.py # run an experiment; freeze code, record metrics +rgit run --from feat_ab12 -- python eval.py # record a recalled variant + lineage +``` + +`rgit run` records the command, base commit, exit status, content-addressed code +snapshot, and metrics from `rgit_metrics.json` or stdout. Any code diff is +staged as a Proposal for review. + +Capsules remember intent; Runs preserve execution and measurements. Together, +they give auto-research agents a durable history for comparing variants and +deciding what to try next. `--from` records lineage but does not run recall; +after approval, the new Capsule becomes a variant of the source. Use +`--with ` to record approved Capsules active in the Run. + +### 2. Share Memory with Your Team + +The graph is served over MCP **read-only** (`recall` / `compose` / `get`, plus the query commands `compare` / `ablation` / `provenance`). Point a teammate's client at your `rgit mcp` server and they get the same Feature Capsules and the same answers. Their session then regenerates an idea onto their code using their subscription. The memory is shared; the intelligence is local. -The five-step loop above is the core. These show up as your store grows — run `rgit --help` for any of them: +## Updating + +```bash +rgit update +``` + +
+Learn more -| Command | What it does | -|---------|--------------| -| `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 install details above | -| `rgit run --from ` | run a recalled variant and link the new run as a `variant_of` the original | -| `rgit compare ` | which variant won: ranked table, Δ vs baseline, ★ winner | -| `rgit provenance ` | per-feature clean (capsule) vs agent-adapted (frozen) diff for a run | -| `rgit mcp` | serve the graph read-only so a teammate's client can recall against it | -| `rgit digest scan [A..B]` | cluster a mature repo's git history into a scored digestion plan (`rgit init` offers this interactively); `rgit digest status` shows progress, the **rgit-digest** skill drains the queue into `origin=backfill` capsules, and `rgit digest clear` removes them all if you change your mind | +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. ---- +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, but the reminder is not. Silence it for good with `rgit update --off`, or per-environment with `RGIT_UPDATE_CHECK=0`. + +
+ +## More commands + +As your store grows, these additional commands become useful. Run `rgit --help` to learn more about any of them: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
CommandWhat it does
rgit watchfree, deterministic background capture that 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-hooksopt-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> -- <command>run and record an experiment for an implementation regenerated from a Capsule; after its Proposal is approved, the resulting Capsule is saved as a variant_of the source
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
rgit mcpserve the graph read-only so a teammate's client can recall against it
rgit digest scan [A..B]cluster a mature repo's git history into a scored digestion plan (rgit init offers this interactively); rgit digest status shows progress, the rgit-digest skill drains the queue into origin=backfill capsules, and rgit digest clear removes them all if you change your mind
+ +See the [command-line guide](https://github.com/StepzeroLab/research-git/wiki) +for every command and option. ## License -

- MIT © Stepzero Lab -
- Core contributors: Yuxiang Lin · Fengrong Wan · Jiajun Sun -

+MIT diff --git a/assets/awesome-rgit-demo.svg b/assets/awesome-rgit-demo.svg new file mode 100644 index 0000000..4488a18 --- /dev/null +++ b/assets/awesome-rgit-demo.svg @@ -0,0 +1,340 @@ + + research-git capture and removal workflow in Codex + Codex fixes and automatically captures a real KTransformers FlashInfer MLA precision invariant, then uses the saved capsule to safely remove that optimization while preserving the Torch fallback. + + + + + + + + + + + + + + + + + + + + + + + + ktransformers — codex — 100×30 + + + + + + >_ OpenAI Codex (v0.144.4) + model: gpt-5.6-sol medium /model to change + directory: ~/Downloads/ktransformers + + + + + › Fix FlashInfer MLA precision and validate it against the Torch reference. + + + + • Explored + + + + └ rg -n "softmax_scale|FlashInfer" ktransformers/operators ktransformers/util + └ util/utils.py: decode used q_head_dim ** (-0.5) + + + • Edited transformers.py and util/utils.py + + + + + └ Passed layer.self_attn.softmax_scale into decode planning + └ Preserved the Torch reference path + + + • Ran precision checks + + + + + └ Compared FlashInfer with the Torch reference + └ Verified model-configured attention scaling + └ HumanEval → 89.6 + + + + + • $research-git:rgit-capture + + + + └ rgit capture → proposal prop_4c8fa1b2 created + └ rgit pending --json → 1 proposal + └ capsule-segmenter → 1 candidate + └ rgit resegment prop_4c8fa1b2 --from-json - + └ Candidate ready for human review + + + + + + Capsule candidate: flashinfer-mla-model-scale — Preserve the model-configured scale and Torchparity. Require HumanEval 89.6 before enabling FlashInfer MLA. Keep it? + + + + › Keep it. + + • Saved flashinfer-mla-model-scale as a capsule. + • 840 commits later • 345,104 lines changed since this capsule was saved. + + + + + + + + + + + + + + + + + + › Add long-context chunked prefill and decode replanning. + • Explored attention and cache planning + + + + + └ Traced prefill, decode, and KV-cache paths + └ Found chunk boundaries in cache planning + + + • Edited attention.py and cache.py + + + + + └ Updated chunk planning without changing decode semantics + └ Long-context tests passed; committed changes + + + + + + + + › Keep complete Transformer layers available for CPU offload. + • Explored transfer maps and device dispatch + └ Found GPU-only assumptions in attention routing + • Edited dispatch and mixed-device configs + └ GPU-only and GPU+CPU tests passed + + + + + + › Integrate Triton and vendor-specific attention backends. + • Explored backend routing and kernel guards + └ Compared Torch, Triton, and vendor paths + • Edited backend dispatch and precision guards + └ Reference parity checks passed + + + + + + › Add SGLang serving and support new model families. + • Explored server, adapters, and model registry + └ Traced runtime and configuration boundaries + • Edited serving and model integration + └ Integration suite passed; committed changes + + + + + › Add AMX and AVX kernel variants for MoE inference. + • Explored CPU kernels and quantized layouts + └ Added vectorized expert execution paths + • Ran kernel benchmarks and correctness tests + └ Performance checks passed; committed changes + + + + + › Support Qwen, DeepSeek, and multimodal model families. + • Explored model loaders and architecture adapters + └ Added configs, mappings, and runtime guards + • Ran model integration suites + └ Supported families passed smoke tests + + + + + › Add distributed serving and scheduler improvements. + • Explored workers, queues, and request routing + └ Updated scheduler and distributed execution + • Ran multi-worker integration tests + └ Serving checks passed; committed changes + + + + + › Harden quantized weight loading and release tooling. + • Explored loaders, packaging, and CI workflows + + + + └ Inspected RAWINT4, Marlin, and loader mappings + └ Traced wheel, submodule, and release workflows + └ Fixed quantized formats and release paths + + + • Ran build and compatibility checks + + + + └ Built CPU and CUDA package variants + └ Quantized loader compatibility checks passed + └ Release validation passed; committed changes + + + + + + + + › $research-git:rgit-recallRemove the FlashInfer MLA optimization but keep generation behavior unchanged. + + + • $research-git:rgit-recall + + + + └ recall("FlashInfer MLA") → feat_83ad710c + └ Resolved depends_on graph → no additional capsules + └ compose(["feat_83ad710c"]) → current archived source + └ Recalled Capsule flashinfer-mla-model-scale: intent, knobs, assumptions, and guide + + + + + + • Explored + + + + └ rg -n "flashinfer|mla" archive/ktransformers/ → 181 matches + └ Located the legacy Torch attention path + + + • Edited archived FlashInfer MLA paths + + + + + └ Removed FlashInfer MLA dispatch and imports + └ Kept model scaling and the Torch attention path + + + • Ran validation + + + + + └ Torch and long-context validation → passed + └ rg -n "flashinfer_mla" archive/ktransformers/ → no matches + └ Long-context decode parity passed + + + + + Removed the FlashInfer MLA optimization without reverting unrelated attention work. + The Torch fallback remains active; the capsule is preserved for future use. + + + + + + >_ OpenAI Codex (v0.144.4) + model: gpt-5.6-sol medium /model to change + directory: ~/Downloads/ktransformers + + + + + + + + + + › + Ask Codex to do anything + Fix FlashInfer MLA precision and validate it against the Torch reference. + Ask Codex to do anything + Keep flashinfer-mla-model-scale. + Ask Codex to do anything + @research-git:rgit-recall + $research-git:rgit-recallRemove the FlashInfer MLA optimization but keep generation behavior unchanged. + Ask Codex to do anything + + + + Keep it. + + + + + $research-git:rgit-recall + Remove the FlashInfer MLA optimization but keep generation behavior unchanged. + + + + + + + + gpt-5.6-sol medium · ~/Downloads/ktransformers · Main [default] + + diff --git a/assets/logo.png b/assets/logo.png new file mode 100644 index 0000000..4e88ab0 Binary files /dev/null and b/assets/logo.png differ diff --git a/assets/rgit-capsule-capture-workflow.svg b/assets/rgit-capsule-capture-workflow.svg new file mode 100644 index 0000000..684cfcb --- /dev/null +++ b/assets/rgit-capsule-capture-workflow.svg @@ -0,0 +1,110 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/rgit-capsule-recall-workflow.svg b/assets/rgit-capsule-recall-workflow.svg new file mode 100644 index 0000000..d67515b --- /dev/null +++ b/assets/rgit-capsule-recall-workflow.svg @@ -0,0 +1,78 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/assets/rgit-digest-skill-input.svg b/assets/rgit-digest-skill-input.svg new file mode 100644 index 0000000..1f94be3 --- /dev/null +++ b/assets/rgit-digest-skill-input.svg @@ -0,0 +1,21 @@ + + Run the research-git digest skill in Codex + A compact Codex terminal input referencing the research-git digest skill to digest repository history. + + + + + + + your-project — codex + + + › + @research-git:rgit-digest + Digest this repository's history. + diff --git a/assets/rgit-recall-plain-text-input.svg b/assets/rgit-recall-plain-text-input.svg new file mode 100644 index 0000000..a4e3907 --- /dev/null +++ b/assets/rgit-recall-plain-text-input.svg @@ -0,0 +1,19 @@ + + Recall an earlier idea in Codex + A compact Codex terminal input asking an agent to bring back the re-ranking retrieval step. + + + + + + + your-project — codex + + + › + Bring back the re-ranking retrieval step. + diff --git a/assets/rgit-recall-skill-input.svg b/assets/rgit-recall-skill-input.svg new file mode 100644 index 0000000..c675bff --- /dev/null +++ b/assets/rgit-recall-skill-input.svg @@ -0,0 +1,21 @@ + + Recall an earlier idea explicitly in Codex + A compact Codex terminal input referencing the research-git recall skill to bring back the re-ranking retrieval step. + + + + + + + your-project — codex + + + › + @research-git:rgit-recall + Bring back the re-ranking retrieval step. + diff --git a/assets/rgit-run-experiment.svg b/assets/rgit-run-experiment.svg new file mode 100644 index 0000000..9aab5f3 --- /dev/null +++ b/assets/rgit-run-experiment.svg @@ -0,0 +1,19 @@ + + Ask Codex to run and record a recalled experiment + A compact Codex terminal input telling the agent that the re-ranking step is ready and asking it to run the evaluation and record the results with research-git. + + + + + + + your-project — codex + + + › + The re-ranking step is ready. Run its evaluation and record the results with research-git. +