opencode-clm 0.1.1 → 0.2.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,305 +1,107 @@
 # 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.
+```
+  ____ _     __  __
+ / ___| |   |  \/  |
+| |   | |   | |\/| |
+| |___| |___| |  | |
+ \____|_____|_|  |_|     opencode-clm: the model manages its own context in OpenCode
+```
 
-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)).
+`opencode-clm` is an [OpenCode](https://opencode.ai) plugin that runs a model as a Context
+Language Model. Before each request the plugin writes the conversation to a text file; the
+model edits that file with its ordinary tools, and the edited text is what it receives on
+the next request. OpenCode's stored session stays unchanged. It ports
+[pi-clm](https://github.com/lolipopshock/pi-clm) 1.0.0, the Pi extension that accompanies
+the paper [Context Language Models](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.
+Tested with OpenCode 1.18.34. The package holds two plugins, and OpenCode loads them from
+two lists:
 
-From npm, once published, in `opencode.json`:
+- the **server plugin** (`index.ts`) in `plugin` of `opencode.json`: the mirror, edits,
+  budget, tools, and the `/clm` and `/clm-compact` commands;
+- the **TUI plugin** (`tui.ts`) in `plugin` of `tui.json`: the `/clm` panel.
 
-```json
-{ "plugin": ["opencode-clm"] }
+```sh
+opencode plugin opencode-clm        # project: adds it to .opencode/opencode.json and .opencode/tui.json
+opencode plugin -g opencode-clm     # global: opencode.json(c) and tui.json in ~/.config/opencode
 ```
 
-From a local clone:
+`opencode plugin` detects both targets from the package and writes the spec to both
+files. To do it by hand, add `"opencode-clm"` to both lists:
 
-```json
-{ "plugin": ["file:///path/to/opencode-clm/index.ts"] }
+```jsonc
+// opencode.json
+{ "plugin": [["opencode-clm", { "budget": "64k" }]] }
+// tui.json
+{ "plugin": ["opencode-clm"] }
 ```
 
-## Configuration
-
-Pass options as the second element of a plugin tuple:
-
-```json
-{ "plugin": [["opencode-clm", { "budget": "64k", "gate": "shrink" }]] }
+Options go on the `opencode.json` entry only; the TUI plugin finds that entry and reads
+the same options (`mirrorDir` above all). It recognises `opencode-clm`,
+`opencode-clm@<version or source>` (including the `opencode-clm@file:…` form `opencode
+plugin` writes for a tarball), and `file://` URLs or paths that name this package or its
+`index.ts`. From a local clone, use `file:///path/to/opencode-clm/index.ts` in
+`opencode.json` and `file:///path/to/opencode-clm/tui.ts` in `tui.json`.
+
+With the TUI plugin, a typed `/clm …` line runs in the TUI and costs no model turn: the
+panel opens, or a toast answers, or the setting changes. Only `/clm reset` goes to the
+server command. Without the TUI plugin (or with `opencode run --command clm`), the server
+command answers `/clm` as text, which costs one model turn because OpenCode cannot cancel
+a command. Version 0.1.0 on npm has the server plugin only; the panel and `/clm config`
+arrive with 0.2.0.
+
+## Quick start
+
+| command | what it does |
+|---------|--------------|
+| `/clm` | open the panel: **overview** (context size per request, fixed overhead and usable budget, every accepted edit) <br><img src=".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 will contain) · **edits** (each revision, message by message, with a side-by-side diff) <br><img src=".github/images/edits.png" alt="The edits page: a tool result before and after the model shortened it" width="720"> |
+| `/clm status` | a toast: CLM on or off, revision, last request size, budget, fixed overhead, last outcome (the server command's text adds the changed settings) |
+| `/clm config` | open **settings**; `/clm config <setting> <value>` changes one, `/clm config reset` drops this session's changes <br><img src=".github/images/settings.png" alt="The settings page: sizes, files, and every setting" width="720"> |
+| `/clm-compact [instructions]` | ask the model to compact its context now; text you add (what to keep, for example) goes into the prompt. The result shows on the **edits** page |
+| `/clm on` / `off` / `reset` | apply edits or send the raw history for this session (the `editing` setting); `reset` drops the accepted revision (server command, one model turn) |
+
+In the panel: `1–4` or `Tab` switch pages, `← →` step through the overview's list
+(edits, rejections, resets, compactions, now) or the edits page's revisions, `z` zooms
+the chart, `Enter` opens the selection, `r` reloads, `q` closes.
+
+## Docs
+
+- [How it works](docs/how-it-works.md): the mirror, edits, the budget, compaction, the panel, safety.
+- [Configuration](docs/configuration.md): sizing the budget, every setting and its environment variable, `/clm config`.
+- [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}
+}
 ```
 
-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.
-
-**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.
-
-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.
-
 ## 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.
+  Casco): the design and most of the code derive from it, the `/clm` panel included
+  (`src/panel/timeline.ts`, `src/panel/diff.ts` and the page layouts in
+  `src/panel/view.ts` port its `timeline.ts`, `diff.ts` and `viewer.ts`). 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)

package/index.ts

@@ -34,12 +34,19 @@ import { buildCompactPrompt, loadCompactPrompt } from "./src/compact.ts";
 import { continuityTools } from "./src/continuity.ts";
 import { replaceInPlace, type OcMessage } from "./src/opencode.ts";
 import { statusText, systemGuidance } from "./src/presentation.ts";
+import { COMPACT_COMMAND, COMPACT_TEMPLATE, STATUS_COMMAND, STATUS_TEMPLATE } from "./src/commands.ts";
+import { changeSetting, resetSettings, showSetting } from "./src/overrides.ts";
+import { settingsText } from "./src/settings-table.ts";
+import { parseClmCommand, type Page } from "./src/panel/command.ts";
+import { buildPanelModel } from "./src/panel/model.ts";
+import { panelPageText } from "./src/panel/text.ts";
+import { readSessionDirectory } from "./src/session-files.ts";
+import { fallbackBudget, settingsView } from "./src/tui/data.ts";
 import { resolveSettings, SKILLS_DIR, type ClmSettings } from "./src/settings.ts";
 import { loadSteeringDocument, steeringPromptSection, type SteeringDocument } from "./src/steering.ts";
 
 export const PLUGIN_ID = "opencode-clm";
-export const STATUS_COMMAND = "clm";
-export const COMPACT_COMMAND = "clm-compact";
+export { COMPACT_COMMAND, STATUS_COMMAND } from "./src/commands.ts";
 
 /** Opening words of the system prompts of OpenCode 1.18 helper agents (title, summary, compaction). */
 const HELPER_PROMPTS = [
@@ -48,7 +55,7 @@ const HELPER_PROMPTS = [
 	"You are a context summarization agent",
 ];
 
-const STATUS_USAGE = "Usage: /clm [status | path | on | off | reset]";
+const STATUS_USAGE = "Usage: /clm [overview | input | edits | settings | status | path | on | off | reset | config [setting [value] | reset]]";
 
 type ToastVariant = "info" | "success" | "warning" | "error";
 
@@ -107,7 +114,7 @@ export const server: Plugin = async (input: PluginInput, options?: PluginOptions
 		const id = checkSessionID(sessionID);
 		let existing = sessions.get(id);
 		if (!existing) {
-			existing = ClmSession.open(id, settings).then((clm) => {
+			existing = ClmSession.open(id, settings, { steering }).then((clm) => {
 				if (clm.loadWarning) toast(`state reset for ${id}: ${clm.loadWarning}`, "warning");
 				return clm;
 			});
@@ -132,11 +139,51 @@ export const server: Plugin = async (input: PluginInput, options?: PluginOptions
 		return total;
 	};
 
-	async function statusCommand(clm: ClmSession, argument: string): Promise<string> {
+	/**
+	 * `/clm config …` as text (pi-clm's `/clm config` semantics; the TUI opens the settings
+	 * page instead). `words` keep their case: values may be paths.
+	 */
+	async function configCommand(clm: ClmSession, words: string[]): Promise<string> {
+		const [name, ...valueWords] = words;
+		const { base, effective } = clm.settingsValues();
+		const format = { modelWindow: clm.limits.context };
+		if (!name) return settingsText(base, effective, format, clm.settingsWarning);
+		if (name.toLowerCase() === "reset" && valueWords.length === 0) {
+			await resetSettings(clm.store.directory);
+			await clm.refreshSettings(true);
+			toast("CLM settings reset to the defaults.");
+			return "CLM settings reset to the defaults for this session.";
+		}
+		if (valueWords.length === 0) return showSetting(name, effective, format);
+		const result = await changeSetting(clm.changeRequest(input.directory), name, valueWords.join(" "));
+		await clm.refreshSettings(true);
+		toast(`CLM ${result.text}.`);
+		return `CLM ${result.text}. It applies from the next request.`;
+	}
+
+	/** `/clm overview|input|edits|settings` outside the TUI: the panel page as plain text. */
+	async function pageCommand(clm: ClmSession, page: Page): Promise<string> {
+		const files = await readSessionDirectory(clm.store.directory, clm.sessionID);
+		const budget = fallbackBudget(clm.settings, clm.limits);
+		const model = buildPanelModel(files, budget ? { budget } : {});
+		model.enabled = clm.enabled;
+		const format = { ...(clm.limits.context ? { modelWindow: clm.limits.context } : {}) };
+		model.settings = settingsView(clm.settingsValues(), model, { format, ...(clm.settingsWarning ? { warning: clm.settingsWarning } : {}) });
+		return panelPageText(model, page);
+	}
+
+	async function statusCommand(clm: ClmSession, args: string): Promise<string> {
+		await clm.refreshSettings();
+		const words = args.split(/\s+/).filter(Boolean);
+		const argument = (words[0] ?? "").toLowerCase();
+		if (argument === "config") return configCommand(clm, words.slice(1));
+		const command = parseClmCommand(`/clm ${args}`);
+		if (args !== "" && command?.kind === "open") return pageCommand(clm, command.page);
+		if (words.length > 1) return `${STATUS_USAGE}\nUnknown argument: ${JSON.stringify(args)}`;
 		switch (argument) {
 			case "":
 			case "status": {
-				const text = statusText(clm.status(steering));
+				const text = statusText(clm.status());
 				toast(text.split("\n").slice(0, 3).join("\n"));
 				return text;
 			}
@@ -144,7 +191,9 @@ export const server: Plugin = async (input: PluginInput, options?: PluginOptions
 				return `CLM mirror: ${clm.mirrorPath}`;
 			case "on":
 			case "off": {
-				await clm.setEnabled(argument === "on");
+				// The same override the TUI and `/clm config editing` write.
+				await changeSetting(clm.changeRequest(input.directory), "editing", argument);
+				await clm.refreshSettings(true);
 				toast(`CLM ${argument} for this session`);
 				return argument === "on"
 					? "CLM is on for this session: the mirror is refreshed before the next request."
@@ -156,12 +205,12 @@ export const server: Plugin = async (input: PluginInput, options?: PluginOptions
 				return "CLM dropped the accepted revision: the next request carries the stored history, and the mirror is rewritten from it.";
 			}
 			default:
-				return `${STATUS_USAGE}\nUnknown argument: ${JSON.stringify(argument)}`;
+				return `${STATUS_USAGE}\nUnknown argument: ${JSON.stringify(args)}`;
 		}
 	}
 
 	function compactCommand(clm: ClmSession, argument: string): string {
-		return buildCompactPrompt(loadCompactPrompt(settings.compactPromptPath), {
+		return buildCompactPrompt(loadCompactPrompt(clm.settings.compactPromptPath), {
 			mirror: clm.mirrorPath,
 			current: clm.lastReading?.estimated ?? 0,
 			budget: clm.resolvedBudget()?.budget,
@@ -176,11 +225,11 @@ export const server: Plugin = async (input: PluginInput, options?: PluginOptions
 				const ours = {
 					[STATUS_COMMAND]: {
 						description: "CLM: status of the editable context; /clm path | on | off | reset",
-						template: "Show the CLM status. $ARGUMENTS",
+						template: STATUS_TEMPLATE,
 					},
 					[COMPACT_COMMAND]: {
 						description: "CLM: ask the model to compact its context by editing the mirror",
-						template: "Compact your context. $ARGUMENTS",
+						template: COMPACT_TEMPLATE,
 					},
 				};
 				for (const [name, definition] of Object.entries(ours)) {
@@ -213,11 +262,12 @@ export const server: Plugin = async (input: PluginInput, options?: PluginOptions
 			} catch {
 				return;
 			}
-			if (!clm.state.enabled) return;
+			await clm.refreshSettings();
+			if (!clm.enabled) return;
 			const limit = (hookInput.model as { limit?: { context?: number; output?: number } } | undefined)?.limit;
 			if (limit) clm.limits = { context: limit.context || undefined, output: limit.output || undefined };
 			const sections = [systemGuidance(clm.mirrorPath, clm.resolvedBudget()?.budget)];
-			if (steering) sections.push(steeringPromptSection(steering));
+			if (clm.steering) sections.push(steeringPromptSection(clm.steering));
 			output.system.push(sections.join("\n\n"));
 			clm.scope = { ...clm.scope, systemTokens: clm.textTokens(output.system.join("\n")) };
 		},
@@ -310,7 +360,7 @@ export const server: Plugin = async (input: PluginInput, options?: PluginOptions
 				const clm = await session(hookInput.sessionID);
 				const argument = (hookInput.arguments ?? "").trim();
 				text = hookInput.command === STATUS_COMMAND
-					? relay(await statusCommand(clm, argument.toLowerCase()))
+					? relay(await statusCommand(clm, argument))
 					: compactCommand(clm, argument);
 			} catch (error) {
 				const message = `/${hookInput.command} failed: ${describe(error)}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-clm",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "OpenCode plugin for Context Language Models: the model edits a file mirror of its own context, and the edited mirror becomes its next input.",
   "type": "module",
   "license": "MIT",
@@ -23,10 +23,13 @@
   ],
   "main": "./index.ts",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./server": "./index.ts",
+    "./tui": "./tui.ts"
   },
   "files": [
     "index.ts",
+    "tui.ts",
     "src/**/*.ts",
     "skills/**",
     "steering/**",
@@ -51,8 +54,20 @@
   "dependencies": {
     "@opencode-ai/plugin": "^1.18.34"
   },
+  "peerDependencies": {
+    "@opentui/core": ">=0.4.5"
+  },
+  "peerDependenciesMeta": {
+    "@opentui/core": {
+      "optional": true
+    }
+  },
   "devDependencies": {
+    "@opentui/core": "0.4.5",
+    "@opentui/keymap": "0.4.5",
+    "@opentui/solid": "0.4.5",
     "@types/bun": "1.3.14",
+    "@xterm/headless": "6.0.0",
     "typescript": "5.9.3"
   }
 }

package/src/atomic.ts

@@ -0,0 +1,27 @@
+// Atomic replacement of small session files (overrides.json, snapshot.json, rN.json): write
+// a temp file with mode 0600 next to the target, then rename it over the target, so a
+// reader never sees a torn file. Written for this package.
+import { randomUUID } from "node:crypto";
+import { mkdir, open, rename, rm } from "node:fs/promises";
+import { dirname } from "node:path";
+
+export async function writeFileAtomic(path: string, text: string): Promise<void> {
+	await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+	const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		const handle = await open(temporary, "wx", 0o600);
+		try {
+			await handle.writeFile(text, "utf8");
+		} finally {
+			await handle.close();
+		}
+		await rename(temporary, path);
+	} catch (error) {
+		await rm(temporary, { force: true }).catch(() => undefined);
+		throw error;
+	}
+}
+
+export function writeJsonAtomic(path: string, value: unknown): Promise<void> {
+	return writeFileAtomic(path, `${JSON.stringify(value, null, 1)}\n`);
+}