opencode-clm 0.1.1 → 0.3.0

package/CHANGELOG.md

@@ -3,7 +3,7 @@
 From 0.1.1 on, release notes are generated by git-cliff from Conventional Commits and
 published on [GitHub Releases](https://github.com/bcmyguest/opencode-clm/releases).
 
-## 0.1.0 (unreleased)
+## 0.1.0
 
 First release: Context Language Model mode for OpenCode 1.18, ported from pi-clm 1.0.0.
 

package/NOTICE

@@ -23,10 +23,18 @@ Derived from pi-clm (code and model-facing text, adapted for OpenCode):
   src/types.ts                  src/types.ts
   steering/house-brief.md       steering/house-brief.md (byte-identical copy)
   skills/clm-context/SKILL.md   src/skills/live-context/SKILL.md
+  src/panel/timeline.ts         src/timeline.ts (context chart and its zoom levels)
+  src/panel/diff.ts             src/diff.ts (side-by-side diff)
+  src/panel/view.ts             src/viewer.ts (panel pages)
+  src/panel/keys.ts             src/viewer.ts (key handling)
+  src/panel/model.ts            src/viewer.ts (revision view model)
+  src/panel/command.ts          src/index.ts (/clm and /clm config parsing)
 
 Written for this package (structure follows pi-clm, text does not):
   src/presentation.ts (system-prompt protocol section and /clm status text),
-  src/policy.ts (edit gate and its refusal note), src/opencode.ts.
+  src/policy.ts (edit gate and its refusal note), src/opencode.ts, and the OpenCode TUI
+  adapter (tui.ts, src/tui/*, src/panel/lines.ts, src/panel/files.ts,
+  src/session-files.ts).
 
 Context Language Models
   Paper: arXiv 2609.37725. Research code:

package/README.md

@@ -1,318 +1,131 @@
 # opencode-clm
 
-An [OpenCode](https://opencode.ai) plugin that runs a model as a Context Language Model
-(CLM): the model edits a text mirror of its own conversation, and the edited mirror
-becomes its input on the next request. OpenCode's stored session stays unchanged.
+[![npm](https://img.shields.io/npm/v/opencode-clm)](https://www.npmjs.com/package/opencode-clm)
+[![CI](https://github.com/bcmyguest/opencode-clm/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/bcmyguest/opencode-clm/actions/workflows/ci.yml)
 
-It ports [pi-clm](https://github.com/lolipopshock/pi-clm) 1.0.0, the Pi extension that
-accompanies the CLM paper ([arXiv 2609.37725](https://arxiv.org/abs/2609.37725)).
-[PORTING.md](PORTING.md) maps each pi-clm file to its counterpart here.
-
-## Install
-
-Tested with OpenCode 1.18.34.
-
-From npm, once published, in `opencode.json`:
-
-```json
-{ "plugin": ["opencode-clm"] }
 ```
-
-From a local clone:
-
-```json
-{ "plugin": ["file:///path/to/opencode-clm/index.ts"] }
+  ____ _     __  __
+ / ___| |   |  \/  |
+| |   | |   | |\/| |
+| |___| |___| |  | |
+ \____|_____|_|  |_|
+
+opencode-clm
+the agent that manages its own context
 ```
 
-## Configuration
+`opencode-clm` is an [OpenCode](https://opencode.ai) plugin that lets the agent manage its
+own context: before each request the plugin writes the conversation to a file, the
+language model edits that file with its ordinary tools, and the edited version becomes its
+next input. OpenCode's stored session stays unchanged. It ports
+[pi-clm](https://github.com/lolipopshock/pi-clm), the Pi extension for the paper
+[Context Language Models](https://arxiv.org/pdf/2609.37725) and its [research
+codebase](https://github.com/facebookresearch/context-language-models).
 
-Pass options as the second element of a plugin tuple:
+## Install
 
-```json
-{ "plugin": [["opencode-clm", { "budget": "64k", "gate": "shrink" }]] }
+```sh
+opencode plugin opencode-clm        # this project: .opencode/opencode.json and .opencode/tui.json
+opencode plugin -g opencode-clm     # global: opencode.json(c) and tui.json in ~/.config/opencode
 ```
 
-Each option falls back to its environment variable, then to the default. The plugin reads
-them once at load; an invalid value fails the plugin load with an error that names the
-option.
-
-| option | env | default | values |
-|---|---|---|---|
-| `enabled` | `CLM_ENABLED` | `true` | `false` registers no hooks |
-| `budget` | `CLM_BUDGET` | `32000` | tokens (`32000`, `32k`, `1.5m`, `32_000`), or `window` for the model's context window. The model window minus its output limit caps the value |
-| `reserve` | `CLM_RESERVE` | `2048` | tokens held back below the budget for generation |
-| `remindAt` | `CLM_REMIND_AT` | `0.25,0.5,0.75` | fractions (`0.25,0.5`) or percentages (`25/50%`) strictly between 0 and 1; `off` disables all reminders, the budget − reserve reminder included |
-| `gate` | `CLM_EDIT_GATE` | `fit` | `fit`, `shrink` or `none` |
-| `guard` | `CLM_OVERFLOW` | `withhold` | `withhold` or `off` |
-| `observationCap` | `CLM_OBSERVATION_CAP` | off | `characters[:head fraction]`, e.g. `10000:0.5`; at least 200; head fraction defaults to 0.8; `off` or `0` disables |
-| `mirrorDir` | `CLM_MIRROR_DIR` | `<project>/.opencode/clm` | parent of the per-session directories; relative paths resolve against the project |
-| `steering` | `CLM_STEERING` | none | path to a steering document, or `house` for the bundled `steering/house-brief.md`; `none` or `off` disables |
-| `compactPrompt` | `CLM_COMPACT_PROMPT` | built-in | path to a `/clm-compact` template; `default`, `none` or `off` mean the built-in prompt |
-| `estimateFactor` | `CLM_ESTIMATE_FACTOR` | `1` | 1 to 4; multiplies the chars/4 token estimate (1.5–2 for dense content) |
-| `reasoning` | `CLM_REASONING` | `true` | render assistant reasoning in the mirror |
-| `dumpRequests` | `CLM_DUMP_REQUESTS` | `false` | write each transformed request to `<session dir>/requests/nN.json` |
-| `skill` | — | `true` | register the `clm-context` skill; `false` matches pi-clm's CLM mode, which offers no skill |
-| `commands` | — | `true` | register `/clm` and `/clm-compact` |
-
-Booleans accept `true/false`, `1/0`, `on/off` and `yes/no`.
-
-**Choosing `budget`.** The budget counts the whole request, OpenCode's system prompt and
-tool schemas included. With OpenCode 1.18 and its default tools those take about 17,000
-to 19,000 tokens of every request (measured with provider counts), before the
-conversation starts. A budget must hold that overhead, the `reserve`, and a working margin
-for the conversation; the plugin uses 8,000 tokens, room for the task, a few tool results
-and edits. With the default reserve that gives a minimum of about 19,000 + 2,048 + 8,000 ≈
-29,000 tokens; the default 32,000 clears it. More tools (MCP servers, plugins) or a
-steering document raise the overhead.
-
-When the budget is smaller, the session raises it. On the first request that follows a
-measured reply, the plugin takes the provider's input count minus its own conversation
-estimate as the fixed overhead. It measures only while the conversation is at most a
-quarter of that count, so the estimate's error stays small; a session resumed with a long
-history is measured once its context is short. If the provider reports no usage, the
-plugin's own size estimate stands in until a provider count arrives. If budget − reserve
-leaves less than 8,000 tokens after the overhead, the effective budget becomes overhead +
-8,000 + reserve, never above the model window minus its output limit (uncapped while the
-window is unknown). The plugin then logs a `budget-too-small` event, shows a warning
-toast, and tells the model once. When the window cap leaves less than the margin, the
-notice says so; lower `reserve` or use a model with a larger window. The overhead is
-stored in `state.json`, so the raise holds after a restart, and it is measured once per
-session: switching agent or model, or adding an MCP server, later does not update it.
-`/clm` shows the fixed overhead, the usable budget (budget − reserve − overhead) and the
-effective budget when raised.
-
-A steering document carries context-management strategy (when to compact, what to keep);
-the plugin itself states only the editing protocol. The plugin reads the document once at
-load and appends it to the system prompt; `/clm` shows its name and SHA-256 prefix.
-
-A `compactPrompt` template may use `{{mirror}}`, `{{current}}`, `{{budget}}` and
-`{{instructions}}`. The plugin rereads it on every use.
-
-## Commands
-
-- `/clm [status | path | on | off | reset]`: `status` (the default) prints the session's
-  mirror path, revision, accepted and rejected edits, gate, guard, budget reading and
-  active revision, and shows a toast. `path` prints the mirror path. `on` and `off` switch
-  CLM for the session. `reset` drops the accepted revision, so the next request carries
-  the stored history. The command costs one model turn: OpenCode cannot cancel a command,
-  so the model receives the text and repeats it.
-- `/clm-compact [instructions]`: asks the model to compact its context now by editing the
-  mirror. Text after the command is appended to the prompt.
-
-If your config already defines `clm` or `clm-compact`, the plugin keeps your command,
-logs a warning and leaves it alone. A failing command prints `[CLM] /<name> failed:
-<reason>` and shows an error toast.
-
-## Tools
-
-- `clm_annotate`: `action` is `create`, `resolve` or `list`. `create` takes a mirror block
-  id (`source`), `title`, `reason`, `futureAction` and `retention`:
-  - `pin` keeps the exact source text in every request (up to 8,000 tokens);
-  - `continuity` keeps the title, reason, next action and recall id in every request;
-  - `archive` keeps nothing in the request; the source is available through recall.
-- `clm_recall`: returns an annotation's saved source; `maxTokens` 128–8,000, default 2,000.
-
-## Skill
-
-`skills/clm-context/SKILL.md`, adapted from pi-clm's `live-context` skill, tells the model
-when and how to edit the mirror: batched surgical edits, keeping conversational units
-together, durable summaries, and Python scripts that list headers and replace or remove
-blocks by id. The plugin adds the `skills` directory to OpenCode's `skills.paths`.
-
-## How it works
-
-**Mirror.** Before each model request, the plugin writes every message after the first
-user message to `LIVE_CONTEXT.md` in the session directory. Line 1 is a `[[LIVE_CONTEXT
-...]]` header with the revision and document id; each message follows as a block headed
-`[[CTX_TURN document=<id> index=<n> role=<role> id=<block id> protected=<bool>]]`. The
-system prompt and the first user message stay outside the mirror and are always sent. A
-system-prompt section, `## Editable context`, teaches the model the format.
-
-**Editing.** The model edits the mirror with the bash tool (python3, `sed -i`). The edit
-and write tools keep a copy that goes stale when the plugin regenerates the file, so the
-protocol tells the model to avoid them on the mirror. Deleting a block drops the message.
-New text under a tool result replaces its output and keeps the call. New text under an
-assistant header replaces the reply and turns its tool results into notes. A header copied
-with `id=new-NAME` inserts a note. Replacing the whole file with text that has no block
-headers replaces everything after the first user message with one notes block. When a
-bash, edit, write or apply_patch call writes the mirror, the plugin appends a verdict to
-its output (accepted, or the reason for refusal); a heuristic detects bash writes. A
-`[CLM]` note on the next request reports what was applied.
-
-**Commit.** OpenCode has no end-of-turn hook, so the plugin reads the mirror at the start
-of the next request. If the file differs from the last render, the plugin parses it and
-applies it. It refuses a file whose line 1 no longer parses or names another document, a
-file with duplicate or unknown block ids, and a file the edit gate rejects; the context
-then stays as it was.
-
-**Edit gate.** Every gate accepts an edit that keeps the context the same size or smaller.
-For growth: `fit` accepts it while the editable context stays within budget − reserve
-minus the system prompt, tool schemas, pinned text and continuity notes, and accepts everything while the budget is
-unknown; `shrink` rejects it; `none` applies no size check.
+The package holds two plugins: the server plugin (`index.ts`: mirror, edits, budget,
+`/clm`, `/clm-compact`) and the TUI plugin (`tui.ts`: the `/clm` panel). `opencode plugin`
+writes the spec to both files. By hand, add it to both `plugin` lists; options go on the
+`opencode.json` entry only, and the TUI plugin reads them from there:
 
-**Projection checkpoints.** An accepted edit becomes a revision. The checkpoint stores the
-number of flattened raw messages it replaces, their OpenCode message ids, and a SHA-256
-digest of them, with tool-result content excluded so OpenCode's prune does not invalidate
-it. A pruned tool output inside an accepted revision goes out with the revision's text.
-Each later request sends the projected messages plus the raw messages added since.
-When the stored prefix no longer matches (a revert, for example), the plugin drops the
-revision, sends the raw history, and tells the model. Compaction is the exception (see
-Compaction).
-
-**Budget tiers.** Token estimates are chars/4 × `estimateFactor` × a calibration factor
-learned from the provider's reported input sizes (never below 1). The estimate covers the
-system prompt, tool schemas, pinned task, editable context, continuity text and notices.
-Until a size is known, the `[CLM BUDGET]` note names what the estimate leaves out. Reminders fire once per tier, as `[CLM BUDGET]` notes, at each
-`remindAt` fraction and at budget − reserve. Requests are never blocked.
-
-**Observation cap.** When set, each tool result in the sent context keeps at most
-`characters` characters (the head fraction from the start, the rest from the end) plus a
-marker stating how much was cut. The stored output stays complete.
-
-**Overflow guard.** When the estimated request exceeds budget − reserve, the guard
-replaces new tool results, oldest first, with a note naming the tool, call id, size and a
-file in `withheld/` that holds the full output (or, if saving fails, a pointer to the
-session history), until the estimate fits. User and
-assistant messages stay untouched, and no tool runs again. `guard: "off"` disables it.
-
-**Continuity.** Annotations (see Tools) let the model shorten or delete a block while a
-pin, a continuity note or a recall copy keeps what later work needs. The plugin sends
-active annotations as a user-role note after the conversation, and warns the model when they exceed
-8,000 tokens.
-
-**Compaction.** CLM replaces compaction: the model shrinks its own context by editing the
-mirror. Set `"compaction": { "auto": false }` in `opencode.json` while CLM is on, and keep
-auto-compaction only as a fallback for a session that outgrows the window anyway.
-
-When OpenCode compacts:
-1. The plugin applies the accepted revision to the history OpenCode summarizes, so the
-   summary reflects the edited context. It makes no commit or render.
-2. It appends an instruction to the compaction prompt: copy every pin and continuity
-   annotation, listed after it, into the summary verbatim.
-3. When a revision is active and OpenCode reports the finished compaction (the `session.compacted` event or the
-   `experimental.compaction.autocontinue` hook), the next request rebases: the summary
-   becomes the new baseline, the revision number moves on, and the model gets no
-   dropped-revision note. Pins and continuity annotations carry over unchanged, and
-   `events.jsonl` records a `compacted` event.
-
-OpenCode's title, summary and compaction agents get no protocol text.
-
-## State
-
-Each session has a directory `<mirrorDir>/clm-<session id>/` (mode 0700; files 0600):
-
-| file | content |
-|---|---|
-| `LIVE_CONTEXT.md` | the mirror |
-| `state.json` | enabled flag, revision, active checkpoint, measured fixed overhead and budget decision |
-| `annotations.jsonl` | continuity annotations |
-| `events.jsonl` | one line per request, edit, reset, notice and error |
-| `revisions/rN.md` | the mirror text of each accepted revision |
-| `withheld/` | tool outputs held back by the overflow guard |
-| `requests/nN.json` | transformed requests, with `dumpRequests` only |
-
-The plugin deletes session directories untouched for 7 days when it opens another
-session. The default `mirrorDir` lies inside the project; add `.opencode/clm/` to
-`.gitignore`.
-
-## Limitations
-
-- Status, budget and edit outcomes appear as text, toasts and `events.jsonl`. pi-clm's
-  TUI viewer, timeline and diff are not ported: OpenCode server plugins cannot draw panels.
-- No per-session settings panel; `/clm on|off|reset` are the only per-session switches.
-- Model limits and the system-prompt size reach the plugin one request late. On the
-  first request of a process the model window does not yet cap the budget and the
-  estimate omits the system prompt; with `budget: "window"` that request has no budget
-  reading. `/clm-compact` before the first request reports about 0 tokens.
-- Built-in tool descriptions are measured, but not their parameter schemas, so
-  calibration attributes that size to undercounting.
-- A checkpoint ignores changes to stored tool output inside the prefix it covers. An
-  output rewritten by another plugin or an SDK client goes out with the new text, while
-  the mirror and estimate keep the revision's.
-- Hooks fail open: if the transform throws, the request goes out with the raw history and
-  an error toast.
-- The calibration factor lives in memory and restarts at 1 with each process.
-- A subagent (task) session gets its own mirror and state.
-- Not ported from pi-clm: branch-aware restore, the `max_tokens` clamp lift, cancelling
-  Pi's own compaction, and the `oneToolPerTurn` and `sizeTrailer` switches.
-
-## Testing
-
-No model has run through this package. Its tests are unit tests, a load smoke test and a
-mock-server end-to-end test (see Development).
-
-The integration suite (`test/e2e`, 10 tests) drives the real OpenCode binary
-(1.18.34, pinned in CI) against a scripted OpenAI-compatible mock, with temporary HOME
-and XDG directories. It covers: plugin load and command registration (`debug config`,
-`/clm path`, `/clm-compact`); the mirror written and re-rendered each turn; an accepted
-edit whose text reaches the next request; a `shrink` gate refusal and the note the model
-sees; budget nudges at 50% and at budget − reserve; auto-compaction (the summary carries
-the edited text and the summarizer gets the pin instruction; the next request rebases onto
-the summary with no drop note, and a pin survives); receipts
-from `tool.execute.after`; the observation cap; and a second `opencode run --session`
-resuming the revision and mirror. Not covered: the overflow guard, the continuity tools
-and a manual `/compact`.
-
-The server-side suffix-cache work is experimental and unreleased.
-
-## Development
-
-- `bun test`: unit tests.
-- `bun run typecheck`: `tsc --noEmit`.
-- `scripts/smoke.sh`: offline, no model. Checks the `npm pack` file list, that OpenCode
-  loads the plugin from `file://` and registers `/clm`, `/clm-compact` and the skills
-  path with no plugin error in its logs, and how `@opencode-ai/plugin` resolves from the
-  repo, a bare tarball and an offline `npm install`.
-- `bun run test:e2e`: the integration suite above (about 30-55 s). Needs the `opencode`
-  binary (`OPENCODE_BIN` overrides it; `OPENCODE_CLM_E2E_KEEP=1` keeps the temp tree) and
-  npm registry access, because OpenCode installs `@opencode-ai/plugin` into its temporary
-  config directory.
-- CI (`.github/workflows/ci.yml`) runs on pull requests and pushes to `main`: frozen
-  install, typecheck, `bun test`, `npm pack --dry-run`, `scripts/smoke.sh --strict` and the
-  integration suite against `opencode-ai@1.18.34`.
-- Commit messages follow [Conventional Commits](https://www.conventionalcommits.org)
-  (`feat:`, `fix:`, `docs:`, `ci:`, `test:`, `refactor:`, `chore:`; `!` for breaking
-  changes). `pre-commit install` adds a commit-msg hook that checks them.
-
-## Releasing
-
-Releases come from Conventional Commits through [git-cliff](https://git-cliff.org)
-(`cliff.toml`). `feat` bumps minor; `fix` and any commit except `chore` and `style` bump
-patch; a breaking change bumps minor below 1.0.0. v0.1.0 is a single commit,
-`feat: initial release`.
-
-1. Actions → "Prepare release" → Run workflow on `main` (tick `dry_run` to preview).
-   It computes the version (`git-cliff --bumped-version`), bumps `package.json` if needed,
-   commits `chore(release): vX.Y.Z`, tags, pushes and dispatches "Release".
-2. "Release" checks the tag against `package.json`, runs CI on the tag, publishes to npm
-   through trusted publishing (OIDC, provenance, no token), then creates the GitHub
-   Release with git-cliff notes.
+```jsonc
+// opencode.json
+{ "plugin": [["opencode-clm", { "budget": "64k" }]] }
+// tui.json
+{ "plugin": ["opencode-clm"] }
+```
 
-Preview locally: `git-cliff --bumped-version` and `git-cliff --unreleased --strip header`.
-Notes for 0.1.1 and later live in GitHub Releases; CHANGELOG.md holds 0.1.0.
+## Quick start
+
+| command | what it does |
+|---------|--------------|
+| `/clm` | open the panel: **overview** (context size per request + every accepted edit) <br><img src="https://raw.githubusercontent.com/bcmyguest/opencode-clm/main/.github/images/overview.png" alt="The overview page: context size per request, with the requests after which the model edited its context" width="720"> <br> **input** (what the next request contains) · **edits** (per-revision side-by-side diff) <br><img src="https://raw.githubusercontent.com/bcmyguest/opencode-clm/main/.github/images/edits.png" alt="The edits page: a tool result before and after the model shortened it" width="720"> |
+| `/clm overview` / `input` / `edits` / `settings` | open the panel on that page (`timeline` and `edit` also work); without the TUI plugin, print it as text |
+| `/clm status` | a toast: on or off, revision, last request size, budget, fixed overhead, last outcome |
+| `/clm config` | open **settings**; `/clm config <setting> <value>` changes one, `/clm config reset` drops this session's changes <br><img src="https://raw.githubusercontent.com/bcmyguest/opencode-clm/main/.github/images/settings.png" alt="The settings page: sizes, files, and every setting" width="720"> |
+| `/clm-compact [instructions]` | ask the model to compact its own context now; anything you add (e.g. what to keep) is passed along. The result shows on the **edits** page |
+| `/clm on` / `off` / `reset` / `path` | enable, use raw context, discard the accepted revision, show the mirror's path |
+| `/clm budget [value]` | show or change the budget, the same as `/clm config budget` |
+
+With the TUI plugin, typed `/clm …` lines run in the TUI and cost no model turn, and Tab
+completes their subcommands, setting names and values;
+`/clm reset` is handed to the server plugin, also without a turn. The right of the
+session prompt shows `clm <size> / <budget> · r<revision>` (`~` before the size marks an
+estimate the provider has not confirmed; `clm off · r<revision>` while CLM is off).
+
+In the panel: `1–4` or `Tab` switch pages, `← →` step through the overview's markers or
+the edits page's revisions, `z` zooms the chart, `Enter` opens the selection, `r`
+reloads, `q` closes.
+
+## Benchmarks
+
+These numbers come from one machine (AMD Strix Halo, gfx1151, Vulkan) running
+Qwen3.8-Flash-Next (UD-IQ4_XS) through lemonade, on a llama.cpp build with an
+unreleased patch that ports the paper's
+[Suffix Cache Reuse](https://github.com/facebookresearch/context-language-models/tree/main/suffix_cache_reuse)
+(an SGLang patch) to llama.cpp's hybrid models. On a stock server, an edit re-prefills
+everything after the first changed token.
+
+**GSM8K, 50 test problems, edited prompt.** Each problem is primed with an 8-shot prompt
+holding three stale worked examples, then asked again with that block replaced by a
+one-line note, mirroring a CLM edit. Temperature 0, thinking off.
+
+| | reuse after the edit | full prefill |
+|---|---|---|
+| accuracy | 48/50 | 49/50 |
+| median tokens prefilled | 23 | 1,362 |
+| median prompt time | 0.51 s | 5.02 s |
+| median request time | 3.1 s | 7.2 s |
+
+**A live OpenCode session** with opencode-clm 0.2.0 (48k budget, auto-compaction off)
+read and summarised every file under `src/` and `test/` of this repository and wrote its
+notes: 49 requests, 16 accepted edits, 0 rejected. The server reused cache after 23 edits
+and prefilled 11,240 tokens in total, where a prefix-only cache would have prefilled
+214,585 (95% less); requests of 20–48k tokens prefilled 34–3,523 tokens each.
+
+Flash-Next was not trained for CLM, so it makes more edit mistakes than the paper's
+trained models. Hosted APIs are untested.
+
+## Docs
+
+- [How it works](docs/how-it-works.md) — the mirror, what runs without the model, the panel, model and server support, safety.
+- [Configuration](docs/configuration.md) — every setting (editing, budget, reserve, reminders, gate, guard, compaction, cap, steering, one-tool, trailer, compact-prompt, reasoning), plugin options and environment variables.
+- [Architecture](docs/architecture.md) — modules, session files, design notes, known limitations.
+- [Development](docs/development.md) — setup, checks, the integration suites, releasing.
+
+## Citation
+
+If you use opencode-clm in your research, please cite
+[Context Language Models](https://arxiv.org/abs/2609.37725):
+
+```bibtex
+@article{shao2026context,
+  title   = {Context Language Models},
+  author  = {Shao, Rulin and Shen, Shannon Zejiang and Yin, Junjie Oscar and Li, Yuetai and
+             Wang, Minheng and Ivison, Hamish and Poovendran, Radha and Lambert, Nathan and
+             Xiao, Teng and Lewis, Mike and Yih, Wen-tau and Zettlemoyer, Luke and Koh, Pang Wei},
+  journal = {arXiv preprint arXiv:2609.37725},
+  year    = {2026}
+}
+```
 
 ## Credits
 
 - [pi-clm](https://github.com/lolipopshock/pi-clm) 1.0.0 (MIT, Copyright 2026 Emanuel
-  Casco): the design and most of the code derive from it. Model-facing text taken from
-  pi-clm, adapted: the compaction prompt (`src/compact.ts`), the `clm-context` skill, the
-  budget notices, the mirror rejection and receipt messages, and the overflow and
-  observation notes. `steering/house-brief.md` is byte-identical to pi-clm's. Written for
-  this package: the system-prompt protocol section (`src/presentation.ts`), the edit-gate
-  refusal note, and the plugin's own receipts, commands and tool descriptions.
-  [NOTICE](NOTICE) lists the files; [LICENSE](LICENSE) carries pi-clm's notice.
-- Context Language Models, [arXiv 2609.37725](https://arxiv.org/abs/2609.37725), and
-  [facebookresearch/context-language-models](https://github.com/facebookresearch/context-language-models)
-  (CC BY-NC 4.0). This package copies no text from that repository (normalized 5-gram
-  check: no shared span over 6 tokens). The `fit` / `shrink` edit gate and the default
-  25/50/75% reminder steps follow its harness design, and the edit-cost advice in the
-  skill, inherited from pi-clm, covers the same points as the harness prompt in different
-  words. This package is not licensed under CC BY-NC and is not endorsed by its authors.
-
-## AI assistance
-
-Claude Code (Claude Opus) wrote the code and documentation in this repository. The
-maintainer has not hand-reviewed them.
+  Casco): the design and most of the code derive from it, the `/clm` panel included, and
+  most model-facing text is adapted from it. [NOTICE](NOTICE) lists the files.
+- [facebookresearch/context-language-models](https://github.com/facebookresearch/context-language-models)
+  (CC BY-NC 4.0): this package copies no text from it; the `fit` / `shrink` edit gate and
+  the default 25/50/75% reminder steps follow its harness design. This package is not
+  licensed under CC BY-NC and is not endorsed by its authors.
+- Claude Code (Claude Opus) wrote the code and documentation; the maintainer has not
+  hand-reviewed them.
 
 ## License