pi-jev-lens 0.1.0 → 0.2.1

package/README.md

@@ -1,116 +1,86 @@
 # pi-jev-lens
 
-A [pi](https://github.com/earendil-works/pi-mono) extension that **compresses large tool results before they reach the
-model**, using [jev](https://docs.typesafe.ai) (TypeSafe's System One model) to select useful views and code blocks.
-The agent gets a smaller result now and can use `recall` to retrieve omitted text when needed.
+Your coding agent reads a 600-line file to change one function. jev-lens sends the model the outline of the file and
+that one function. The agent can ask for the rest with the `recall` tool, and the footer of the result tells it so.
 
-**Pre-send compression is the main cost lever.** Avoiding the first send saves uncached input tokens without rewriting
-an already-cached message. Pruning later can free context, but may cost more by invalidating part of the prompt cache.
+jev-lens is an extension for [pi](https://github.com/earendil-works/pi-mono), the coding agent. Tool output is most
+of what a coding agent pays for. Every `cat`, every test run and every `grep` goes into the prompt in full and stays
+there for the rest of the session. jev-lens acts before that first send. Code builds a small set of candidate views
+of the output. A view is a subset of the lines of the output, with line numbers. Then [jev](https://docs.typesafe.ai),
+the judgment model from TypeSafe, picks the smallest view that still lets the agent do its next step. Nothing is
+generated or summarized. Every view is made of lines from the original, so the agent can ask for exactly the part
+that it does not have.
 
-The extension has three complementary layers, all enabled by default:
+This is what the model sees instead of a file of 1.5k tokens:
 
-1. **Pre-send compression:** send outlines, relevant code blocks or filtered output instead of the entire result.
-2. **Cache-aware post-send pruning:** after the agent reacts, keep, trim or stub results when the pruning policy permits.
-3. **Durable notes:** retain selected project facts and preferences for future sessions.
-
-## Pre-send compression (the cost lever)
-
-Large text tool results (default: at least 1200 estimated tokens, estimated as characters / 4) are considered for
-compression in pi's `tool_result` hook. Results containing images and calls to `recall` are excluded. Code builds
-candidate **views** from the output, with line numbers and omission markers. Views of code and prose preserve
-retained lines exactly, so edits copied from a view still match the file; views of command output, listings and
-data shorten decorative bars, long runs of spaces and very long lines. Full text is still sent when no suitable reduced view
-is available or classification fails. A conservative subset of bash file displays (`cat a.py b.py`,
-`sed -n '1,80p' x.ts`, line-limited `head`/`tail`, brace groups and globs) gets code or prose views when all displayed
-files have that type. Pipelines may only filter stdin with recognized options. Redirections, substitutions, modifying
-`sed` scripts, mixed code/non-code files and unsupported syntax retain ordinary command handling:
-
-| view | for | keeps |
-|---|---|---|
-| `outline` | code, prose | imports, exports, signatures, headings, doc comments |
-| `relevant` | code | outline plus the full bodies of the blocks jev says the agent will need (second jev step) |
-| `focus` | anything | lines mentioning identifiers from the task and the tool call, with context |
-| `signals` | command output | errors, warnings, failing tests, summary lines, the tail |
-| `sample` | tabular or log-like data | header, a dozen rows, the count |
-| `head_tail` | anything | first and last lines |
-| `testlog` | test output | failures, assertions, tracebacks and summaries |
-| `tree` | directory listings | a sample of entries per directory, with omission counts |
-| `matches` | search output | first matches per file, with omission counts |
-| `log` | repetitive output | representative repeated lines, errors and the tail |
-| `sections` | command output | the first line of every section (grep match groups, JSON keys, headings, `COMMAND:`-style markers, paragraphs); a second jev step puts back the sections the agent needs, giving `relevant` |
-
-Code structure comes from tree-sitter (grammars from `@vscode/tree-sitter-wasm` plus `@binclusive/tree-sitter-kotlin-wasm`):
-TypeScript, TSX, JavaScript, Kotlin, Java, Rust, Python, Go, C, C++, C#, Ruby, PHP, Bash, CSS. Large classes and impl blocks
-are split into their members. Other languages fall back to regex heuristics that know the common declaration keywords.
-
-jev answers two questions over the task, the assistant's text before the call (not hidden thinking), and a preview of
-each view: *which view is the smallest that still suffices* (Choice) and *will the next step need the exact full text*
-(Noul). Thresholds decide when to send full text. For code, when a reduced view is chosen (or with the `outline`
-policy, always), a second step asks jev which block bodies to expand. If the expanded view reaches 90 % of the
-original character count, full text is sent instead.
-
-When a result is compressed, its full output is kept in `details` (persisted in the session, not included in the model
-prompt) and served by a `recall` tool using an id, a line range or a pattern. This storage covers pre-send compression,
-not results that were only pruned post-send; those must be obtained by re-running the original tool. Every recall is
-logged as feedback on the reduced view. Set `JEV_LENS_PRESEND=0` to turn pre-send compression off.
+```
+  1│ import { parse } from "./parse.js";
+     ⋯ 14 lines omitted
+ 16│ export function normalizeCategory(raw) {
+ 17│   const key = raw.trim().toLowerCase();
+ 18│   return ALIASES[key] ?? key;
+ 19│ }
+     ⋯ 61 lines omitted
+ 81│ export function categoryReport(entries) {
+     ⋯ 20 lines omitted
+
+[jev-lens: showing the "relevant" view, 9 of 102 lines. Omitted lines are marked ⋯. Call recall(id: "…") for the
+full output, or recall(id, lines: "a-b") / recall(id, pattern: "...") for a slice.]
+```
 
-## Post-send pruning (the context-budget layer)
+## What the numbers say
 
-This is a secondary pass, not the source of the initial pre-send savings. It classifies the result the agent saw
-(which may already be compressed) after the agent has reacted to it:
+We measured the defaults on 500 real agent trajectories (OpenHands on SWE-rebench: 3300 large tool results, 11.6
+million tokens) and on our own daily pi sessions. A token is the unit that a model provider bills. The research log
+is STATUS.md. These are the main results:
 
-| decision | what happens in later prompts |
+| result | source |
 |---|---|
-| **keep** | leave the result unchanged, including any pre-send compression |
-| **trim** | keep the head and tail; drop the middle |
-| **forget** | replace the result with a one-line stub; re-run the tool if needed |
-
-Prompt caches match on an exact prefix. Any edit to an already-sent message invalidates the cache from that point on.
-The extension limits repeated rewrites using persisted decisions:
-
-1. **Classify after reaction.** Text-only tool results of at least `JEV_LENS_MIN_TOKENS` are queued for classification after
-   the next assistant message supplies evidence of what happened next. Results still buffered at agent end are
-   classified without that reaction. Results with an existing decision or an in-flight classification are skipped.
-2. **Apply, then freeze the decision.** The `context` hook waits briefly for in-flight classifications and applies
-   pending decisions when the selected mode permits. Decisions are persisted and restored at session start; applied
-   decisions are re-applied on later calls. Transforms remain identical for unchanged input and configuration
-   (changing trim settings can change the rendered text).
-3. **Choose when to rewrite.** `budget` (default) applies pending prunes when their savings meet both the configured
-   minimum and a fraction of the tail they would rewrite. `rolling` applies them at the next context hook; `batch`
-   waits for a cold cache. All modes allow application after the configured idle TTL, and compaction marks pending
-   decisions as applied.
-
-There is no monotonic cut boundary: a late classification can still rewrite an older result after a newer decision
-has been applied. Persisted decisions prevent repeated reclassification, but do not guarantee an unchanged cache prefix.
-
-Tool results are never removed, only rewritten, because every `function_call` must keep a matching output.
-
-## Durable notes (cross-session memory)
-
-Separately from compression and pruning, jev assesses whether content is worth remembering across sessions.
-Selected notes are written to `<project>/.pi/jev-lens.md` as classifications complete and injected into the system
-prompt from a snapshot taken at the next session start. Agent end and session shutdown wait up to
-`JEV_LENS_CLASSIFY_WAIT_MS` for outstanding classifications. Requests still unfinished at shutdown are aborted and
-late responses discarded, so a slow request may not produce a note. This is not a fourth pruning bucket: saving a
-note does not remove its source from the prompt.
+| 79 % fewer tokens sent for large tool results (11.6M became 2.4M) | the 500 benchmark trajectories |
+| 88 % fewer on command output (test runs, grep, build logs), 58 % on docs, 47 % on listings, 31 % on code | the same, per kind of output |
+| 31 % fewer tokens for large tool results | our own sessions with gpt-6-astra, which reads code with `cat` and runs few tests |
+| 2 of 26 later edits missed their block, 0.3 % of results had a dropped line quoted, 2.2 % had a dropped identifier used | the harm side, same 500 trajectories |
+| 8 % lower cost, 17 % smaller final prompt, the same pass rate, zero recalls | live end-to-end runs in pi where the agent reads big files, 3 runs each |
+
+Read the two savings numbers together. The benchmark agent spends its output budget on pytest runs and grep, and
+those compress to almost nothing. An agent that mostly reads source code sits closer to the code number, because
+code is the one thing that jev-lens does not compress unless jev is confident. Both numbers are shares of large tool
+results only. Over a whole session, the footer counts the system prompt, the conversation and every small result too,
+so it will show a lower percentage. What you save depends on what your agent reads.
+
+Three results shaped the design:
+
+1. Compress before the first send, not after. Pruning old results later removes 19 % of the tokens and costs 17 %
+   more money, because every rewrite of an old message breaks the prompt cache. The prompt cache is the provider's
+   discount for a prompt prefix that did not change since the last call. Post-send pruning is still in the code, but
+   it is off by default.
+2. Code is different. Test logs and grep output can lose 90 % of their lines and the agent does not miss them. The
+   agent edits from code, and an edit fails when its old text is a line that the model never saw. So views of code
+   keep every retained line byte for byte, and code is sent in full unless jev is confident. The policy that always
+   sends an outline saved more and missed 17 % of later edits. It is available, but you must turn it on.
+3. Views built in code beat prompt tuning. In four rounds, a researcher model rewrote the questions to jev and the
+   thresholds. None of its changes held up on data that it had not seen. Every gain that held was a new kind of view:
+   only the failing tests, grep match groups, JSON keys, the file that the agent read with `cat`.
 
 ## Install
 
 ```sh
-pi install npm:pi-jev-lens            # from npm
-pi install git:github.com/dizk/pi-jev-lens   # or straight from GitHub
+pi install npm:pi-jev-lens                    # from npm
+pi install git:github.com/dizk/pi-jev-lens    # or from GitHub
 ```
 
-The classifier is [jev](https://typesafe.ai), TypeSafe's System One model, so it needs a TypeSafe API key
-(get one at [console.typesafe.ai](https://console.typesafe.ai)). Three ways to provide it, in the order they are tried:
+jev needs a TypeSafe API key. You can get one at [console.typesafe.ai](https://console.typesafe.ai). jev-lens looks
+for the key in this order:
 
 1. `TYPESAFE_API_KEY` in the environment.
-2. `/jev-lens key` inside pi: prompts for the key (or `/jev-lens key ts_...`) and stores it in
-   `~/.pi/agent/jev-lens.json`, readable only by you. jev is active from the next tool result, no restart.
-3. A `.env` file next to the installed package (development).
+2. The key that you stored with `/jev-lens key` inside pi. The command prompts for the key, or you can give it as
+   `/jev-lens key ts_...`. The key is stored in `~/.pi/agent/jev-lens.json`, readable only by you. jev is active from
+   the next tool result. You do not have to restart pi.
+3. A `.env` file next to the installed package. This is for development.
 
-Without a key the extension warns at startup and runs a mock classifier that compresses nothing.
-For development, clone the repo and load it directly:
+If no key is found, the extension shows a warning at startup and runs a mock classifier that compresses nothing.
+
+For development, clone the repository and load it directly:
 
 ```sh
 git clone https://github.com/dizk/pi-jev-lens.git && cd pi-jev-lens && npm install
@@ -118,121 +88,168 @@ echo 'TYPESAFE_API_KEY=...' > .env
 pi -e ./index.ts
 ```
 
-Inside pi: `/jev-lens` shows stats (and where the key comes from), `/jev-lens key` stores the key, `/jev-lens list` lists the latest 200 pre-send-compressed tool results with tokens
-before and after, `/jev-lens diff [n]` opens an overlay for the n-th latest one showing the original output with the
-lines the model did not get marked `−` (press `t` to switch to exactly what was sent, `Esc` to close),
-`/jev-lens decisions` lists post-send decisions with probabilities, `/jev-lens file` prints the memory file.
-In the transcript, a compressed `read`/`bash`/`grep`/`find`/`ls` result shows a header line
-`⌁ jev-lens outline · 179 of 1524 tokens (−88 %)` and, expanded (ctrl+e), the text the model saw. The footer shows
-session totals, leading with the share of the session's input tokens jev kept out of the prompt:
-`jev-lens −38% of input (presend −12.3k · 5/8 · 1 recalls, pruned −4.0k · 3, 2 notes)`. The share is
-cut / (sent + cut), where sent is the provider's own input plus cache-read counts over all calls and cut is what every
-compressed or pruned result saved on every call it was part of, so a result compressed early counts on each later call. Set `JEV_LENS_UI=0` to keep pi's own tool rendering. Every call is logged to
-`<project>/.pi/jev-lens.log` (JSON lines).
+## How it works
+
+Every text tool result of at least 1200 estimated tokens (about 5 kB) goes through pi's `tool_result` hook before
+pi stores it or sends it. jev-lens never touches smaller results. Code builds the candidate views. Each view is a
+subset of the lines of the output, with line numbers and markers for the omitted lines. No text is generated.
+
+| view | for | keeps |
+|---|---|---|
+| `outline` | code, prose | imports, exports, signatures, headings, doc comments |
+| `relevant` | code, command output | the outline or the section headers, plus the full bodies that jev says the agent will need (second jev step) |
+| `sections` | command output | the first line of every section: grep match groups, JSON keys, headings, markers like `COMMAND:`, paragraphs |
+| `signals` | command output | errors, warnings, failing tests, summary lines, the tail |
+| `testlog` | test output | failures, assertions, tracebacks and summaries |
+| `matches` | search output | the first matches per file, with a count of the omitted ones |
+| `log` | repetitive output | representative repeated lines, errors and the tail |
+| `tree` | directory listings | a sample of entries per directory, with a count of the omitted ones |
+| `focus` | anything | the lines that mention identifiers from the task and the tool call, with context |
+| `sample` | tabular or log-like data | the header, a dozen rows, the count |
+| `head_tail` | anything | the first and the last lines |
+
+jev then answers two questions. It sees the task, the text that the assistant wrote before the call, and a preview of
+each view. The questions are: which view is the smallest one that is still enough (a choice), and will the next step
+need the exact full text (yes or no). If jev chose an outline or a `sections` view, a second request asks, for each
+block or section, whether the agent will need its body. Those bodies go back into the view. If the result reaches
+90 % of the original size, jev-lens sends the full text instead.
+
+These rules make it safe for the agent to edit from a view:
+
+- Views of code and prose keep every retained line exactly as it is. An edit whose old text was copied from the view
+  still matches the file. Views of command output shorten decorative bars and very long lines.
+- Files that the agent reads through bash (`cat a.py b.py`, `sed -n '1,80p' x.ts`, `head`, brace groups, globs) count
+  as code or prose and get the same views as the `read` tool. If the command also does something else, the output
+  stays command output.
+- jev-lens never reduces the results of the agent's own `edit` and `write` tools.
+- jev-lens sends code in full unless jev is confident that a view is enough. This is the `gate` policy. The
+  `outline` policy always sends an outline plus expanded bodies. It saves more, but it missed 17 % of later edits on
+  real trajectories, so you must turn it on yourself.
+
+The code structure comes from tree-sitter (grammars from `@vscode/tree-sitter-wasm` and
+`@binclusive/tree-sitter-kotlin-wasm`): TypeScript, TSX, JavaScript, Kotlin, Java, Rust, Python, Go, C, C++, C#,
+Ruby, PHP, Bash, CSS. Large classes are split into their members. For other languages, jev-lens uses regular
+expressions that know the common declaration keywords.
+
+When jev-lens compresses a result, it keeps the full output in the result's `details`. pi persists that in the
+session but never sends it to the model. The footer names the `recall` tool, which serves the full output back by
+id, by line range or by pattern. jev-lens logs every recall as a signal that a view was too small.
+
+## In pi
+
+The footer shows the share of the session's input tokens that jev kept out of the prompt, and what it did:
+
+```
+jev-lens −38% of input (presend −12.3k · 5/8 · 1 recalls)
+```
+
+The share is cut divided by sent plus cut. Sent is the provider's own count of input and cache-read tokens over all
+calls. Cut is what every compressed result saved on every call that it was part of.
+
+In the transcript, a compressed result shows a header like `⌁ jev-lens outline · 179 of 1524 tokens (−88 %)`. When
+you expand it with ctrl+e, you see exactly what the model saw. These commands are available:
+
+- `/jev-lens` shows the statistics and where the key comes from.
+- `/jev-lens list` lists the latest 200 compressed results with the tokens before and after.
+- `/jev-lens diff [n]` opens an overlay for the n-th latest result. It shows the original with the lines that the
+  model did not get marked with `−`. Press `t` to see what was sent, and `Esc` to close.
+- `/jev-lens key` stores the API key.
+
+jev-lens logs every decision to `<project>/.pi/jev-lens.log` as JSON lines. Set `JEV_LENS_UI=0` to keep pi's own
+tool rendering.
 
 ### Configuration (environment)
 
 | variable | default | meaning |
 |---|---|---|
-| `JEV_LENS_MODE` | `budget` | `rolling`, `batch` or `budget` (see above) |
-| `JEV_LENS_BUDGET_FRACTION` / `_BUDGET_MIN_TOKENS` | `0.5` / `1000` | budget mode: apply when pending prunes remove at least this share of the tail they rewrite, and at least this many tokens |
-| `JEV_LENS_FORGET_BELOW` | `0.25` | P(needed) below this → forget |
-| `JEV_LENS_TRIM_BELOW` / `_TRIM_ABOVE` | `0.5` / `0.6` | P(needed) below the first and P(outcome only) above the second → trim |
-| `JEV_LENS_DURABLE_ABOVE` | `0.7` | text notes require P(durable) above this; tool pointers require P(durable) above `max(this, 0.85)` |
-| `JEV_LENS_MIN_TOKENS` | `150` | smaller tool results are never touched |
-| `JEV_LENS_CLASSIFY_WAIT_MS` | `2500` | maximum wait for in-flight classification at context, agent end and shutdown |
-| `JEV_LENS_CACHE_TTL_MS` | `300000` | idle longer than this counts as a cold cache |
-| `JEV_LENS_DISABLED` | unset | `1` skips pre-send compression and makes new post-send decisions `keep`; classification, logging and memory notes remain active. Previously applied decisions are still replayed. |
-| `JEV_LENS_PRESEND` | `1` | `0` turns pre-send compression off |
+| `JEV_LENS_PRESEND` | `1` | `0` turns compression off |
 | `JEV_LENS_PRESEND_MIN_TOKENS` | `1200` | smaller results are always sent in full |
-| `JEV_LENS_PRESEND_NEEDS_FULL_ABOVE` / `_FULL_MASS_ABOVE` | `0.5` / `0.5` | send full when P(needs full) or P(full view) exceeds these |
-| `JEV_LENS_PRESEND_EXPAND_ABOVE` | `0.5` | expand a code block's body when P(needed) exceeds this |
-| `JEV_LENS_PRESEND_COMMAND_NEEDS_FULL_ABOVE` | `0.65` | needs-full threshold for command output; the question is phrased for edits, and test runs rarely need exact full text (+3.3 points on the benchmark, no extra misses) |
-| `JEV_LENS_PRESEND_COMMAND_POLICY` | `sections` | when jev picks full for command output but needs-full is under the command threshold, send the section headers and let the second step expand the needed sections (full again if that reaches 90 %). `gate`: jev's view choice stands. |
-| `JEV_LENS_PRESEND_SECTION_EXPAND_ABOVE` | `0.5` | expand a section of command output when P(needed) exceeds this |
-| `JEV_LENS_PRESEND_SECTION_FLOOR` | `0.3` | send full when no section of command output reaches this probability (the expansion step could not tell, typical for docs read for orientation); `0` allows headers alone |
-| `JEV_LENS_PRESEND_CODE_POLICY` | `gate` | jev's needs-full and full-mass gates decide between full and a view; when a view is chosen, selected block bodies are expanded. `outline`: always send an outline plus expanded bodies (saves more, but 17 % of later edits missed their block on 500 real trajectories). |
-| `JEV_LENS_PRESEND_CODE_NEEDS_FULL_ABOVE` | `0.5` | code gate uses the minimum of this and the general needs-full threshold |
-| `JEV_LENS_PRESEND_MIN_CONFIDENCE` | `0` | send full below this choice confidence (0 disables the check); bypassed by outline-first code selection |
-| `JEV_LENS_TRIM_HEAD` / `_TRIM_TAIL` | `15` / `15` | lines retained at each end for post-send trimming |
-| `JEV_LENS_STATE_HEAD` / `_STATE_TAIL` | `2500` / `800` | maximum output characters in post-send classifier excerpts |
-| `JEV_LENS_MODEL` | `jev-latest` | classifier model |
-| `JEV_LENS_CLASSIFIER` | unset | `mock` forces deterministic classifiers without API calls |
-| `JEV_LENS_LOG` | `1` | `0` disables JSON-lines logging |
-| `JEV_LENS_UI` | `1` | `0` disables custom built-in tool rendering |
-| `JEV_LENS_VARIANT` | unset | JSON file with `config`, `prompts` and `views` overrides (also accepts autoresearch's `{ variant }` wrapper); config overrides take precedence over environment settings |
-
-`TYPESAFE_API_KEY` enables the real classifier. The extension loads `.env` from its own directory (and `src/`), not
-from the target project; existing nonempty environment values take precedence.
-
-## How jev is used
-
-Post-send classification uses one request per eligible tool result, with three yes/no questions over the same state
-(`src/classifier.ts`): *needed*, *outcome only*, *durable*. The state holds the task (first and latest user message),
-the tool call and a head/tail excerpt of its output, and what the agent said and called next. User messages and assistant
-text between 40 and 6000 characters get a single *durable* question (disabled with the mock classifier). jev returns
-probabilities, not generated prose: stubs, trims and memory notes are assembled by code. Tool memory notes store only
-a call summary and success/failure marker; user and assistant notes are truncated excerpts. Notes are deduplicated,
-capped at 150 bullets / 8000 characters of bullet text, and loaded as a stable snapshot at session start.
-
-Pre-send selection and optional block expansion use separate requests, in addition to post-send classification.
+| `JEV_LENS_PRESEND_NEEDS_FULL_ABOVE` / `_FULL_MASS_ABOVE` | `0.5` / `0.5` | send full when P(needs full) or P(full view) is above these |
+| `JEV_LENS_PRESEND_CODE_POLICY` | `gate` | `outline`: always send an outline plus expanded bodies (more savings, more missed edits) |
+| `JEV_LENS_PRESEND_CODE_NEEDS_FULL_ABOVE` | `0.5` | code uses the lower of this and the general needs-full threshold |
+| `JEV_LENS_PRESEND_EXPAND_ABOVE` | `0.5` | expand the body of a code block when P(needed) is above this |
+| `JEV_LENS_PRESEND_COMMAND_NEEDS_FULL_ABOVE` | `0.65` | the needs-full threshold for command output |
+| `JEV_LENS_PRESEND_COMMAND_POLICY` | `sections` | when jev picks full for command output but needs-full is low, send the section headers and expand the needed sections. `gate`: keep jev's choice |
+| `JEV_LENS_PRESEND_SECTION_EXPAND_ABOVE` | `0.5` | expand a section when P(needed) is above this |
+| `JEV_LENS_PRESEND_SECTION_FLOOR` | `0.3` | send full when no section reaches this probability, because jev could not tell. `0` allows headers alone |
+| `JEV_LENS_PRESEND_MIN_CONFIDENCE` | `0` | send full below this choice confidence. `0` turns the check off |
+| `JEV_LENS_MODEL` | `jev-latest` | the jev model |
+| `JEV_LENS_CLASSIFIER` | unset | `mock` forces the deterministic classifier, with no API calls |
+| `JEV_LENS_LOG` | `1` | `0` turns logging off |
+| `JEV_LENS_UI` | `1` | `0` turns the custom tool rendering off |
+| `JEV_LENS_VARIANT` | unset | a JSON file with `config`, `prompts` and `views` overrides, as the autoresearch loop writes it |
+| `JEV_LENS_MODE` | `off` | optional post-send pruning, see below |
 
 ## Evaluation
 
+Every change is scored against what the agent did next in a recorded trajectory. That is the only honest judge of
+whether the agent needed the text. The benchmark uses real OpenHands trajectories in `eval/bench/`. The script
+`eval/bench/fetch.sh` downloads the data. The metrics are:
+
+- edit-miss: the agent later edited a line that the view had dropped.
+- quote-miss: the agent quoted text that the view had dropped.
+- ref-miss: the agent used an identifier that only existed in the dropped part.
+
+An edit-miss counts five times in the objective, and edit-misses are rare. So you must score every change that
+touches code views on the 500-trajectory slice, not only on the 100-trajectory holdout.
+
+| slice | large results | saved | edit-miss | quote-miss | ref-miss |
+|---|---|---|---|---|---|
+| 100 trajectories (rows 200-299) | 681 | 77.8 % | 0/7 | 0.6 % | 2.3 % |
+| 500 trajectories (rows 300-799) | 3296 | 79.0 % | 2/26 | 0.3 % | 2.2 % |
+
 ```sh
-npm test                                      # unit tests for the policy, ledger and memory file
-node --import tsx eval/replay.ts <session.jsonl|dir>   # offline: classify a recorded session, simulate post-send pruning
-node --import tsx eval/presend-replay.ts <dir>          # offline: pre-send views vs what the agent did next (edit/quote misses)
-node --import tsx eval/action-graph.ts                  # procedural graph mined from runs, jev as guidance model
-node --import tsx eval/bench/run.ts --from 200 --to 300 # pre-send benchmark on 100 real OpenHands trajectories (holdout)
-node --import tsx eval/bench/run.ts --from 300 --to 800 # the 500-trajectory slice (46 editable code results; use it for anything that touches code views)
-node --import tsx eval/bench/autoresearch.ts --iterations 8   # let a researcher model tune prompts/thresholds on the train slice
-node --import tsx eval/generate.ts --cond baseline     # run the fixture tasks with pi headless
-node --import tsx eval/generate.ts --cond jev
-node --import tsx eval/report.ts                       # compare conditions
+npm test                                                # unit tests, mock classifier
+node --import tsx eval/bench/run.ts --from 200 --to 300 # the holdout, about 4 minutes
+node --import tsx eval/bench/run.ts --from 300 --to 800 # the 500-trajectory slice, about 20 minutes
+node --import tsx eval/presend-replay.ts <session dir>  # replay your own pi sessions from ~/.pi/agent/sessions
+node --import tsx eval/bench/autoresearch.ts --iterations 8   # a researcher model tunes the prompts and thresholds
 ```
 
-`eval/fixture` is a small dependency-free JavaScript project with planted bugs; `eval/tasks/tasks.json` holds ten
-tasks (eight short, a five-part compound and an eight-part marathon), each scored by a hidden test.
+STATUS.md is the research log. It lists every variant that we tried, its numbers, and why the defaults are what they
+are. In short: new code-built views moved the numbers, prompt wording did not, and the small holdout was wrong about
+code until the slice was five times larger.
 
-Benchmark on 100 real OpenHands trajectories (685 large tool results, 2.26M tokens, `eval/bench/`): the default
-pre-send configuration sends 78.6 % fewer tokens for large results with 0 of 15 later edits missing their old text,
-0.6 % quote-misses and 2.3 % ref-misses (an identifier the agent then used that only existed in the dropped part).
-Details, the metric definitions and the autoresearch loop are in `STATUS.md`.
+## Optional: post-send pruning
 
-Headline from the first night of runs (details and caveats in `STATUS.md`): decisions are sensible and the mechanism
-holds (frozen decisions, stable prefix), but under a 10× prompt-cache discount pruning after first send is a
-**context-budget** tool, not a cost tool. Rolling mode cut input tokens 19 % on long sessions and still cost 17 % more
-because each prune rewrites the cached prefix; budget mode keeps the cache (65 % hit vs 70 % baseline) and passed
-12/13 tasks (baseline 13/13). The pre-send compression implemented here targets those costs by avoiding the initial
-send of unnecessary output.
+`JEV_LENS_MODE=budget` (or `rolling`, or `batch`) turns on a second layer. After the agent reacted to a tool result,
+jev judges whether the result is still needed. In later prompts, a result that is not needed is cut to its head and
+tail, or replaced by a stub of one line. jev-lens persists each decision and freezes it after the first use, so the
+cached prefix is rewritten as rarely as possible. The `budget` mode only rewrites when the pending cuts remove at least
+half of the tail that they would touch. On real sessions, this layer frees context but does not save money under
+prompt-cache pricing. That is why it is off by default.
+
+Its settings are `JEV_LENS_BUDGET_FRACTION` and `JEV_LENS_BUDGET_MIN_TOKENS` (`0.5` and `1000`), `JEV_LENS_FORGET_BELOW`
+(`0.25`), `JEV_LENS_TRIM_BELOW` and `JEV_LENS_TRIM_ABOVE` (`0.5` and `0.6`), `JEV_LENS_MIN_TOKENS` (`150`),
+`JEV_LENS_TRIM_HEAD` and `JEV_LENS_TRIM_TAIL` (`15` and `15`), `JEV_LENS_CLASSIFY_WAIT_MS` (`2500`),
+`JEV_LENS_CACHE_TTL_MS` (`300000`), `JEV_LENS_STATE_HEAD` and `JEV_LENS_STATE_TAIL` (`2500` and `800`), and
+`JEV_LENS_DISABLED=1` (new decisions become `keep`). The command `/jev-lens decisions` lists the decisions. jev-lens
+never removes a tool result. It only rewrites it.
 
 ## Using this as a reference
 
-The pieces are independent of pi and can be lifted into another agent:
+The pieces do not depend on pi. You can lift them into another agent:
 
 | piece | file | depends on |
 |---|---|---|
-| candidate views (outline, focus, signals, testlog, tree, matches, log, sample, head/tail) | `src/views.ts` | regex views need no external packages; async code views optionally load `src/treesitter.ts` |
+| candidate views | `src/views.ts` | nothing. The async code views can load `src/treesitter.ts` |
 | tree-sitter blocks and signatures | `src/treesitter.ts` | `web-tree-sitter`, `@vscode/tree-sitter-wasm`, `@binclusive/tree-sitter-kotlin-wasm` |
-| the jev questions, state shape, decision rule, block expansion | `src/presend.ts` | `@typesafe-ai/sdk` |
-| post-send decisions and the frozen, cache-aware ledger | `src/classifier.ts`, `src/policy.ts`, `src/ledger.ts` | `@typesafe-ai/sdk` |
-| the hook wiring for pi (tool_result, context, recall tool, UI) | `index.ts`, `src/ui.ts` | pi |
-| benchmark and metrics on real trajectories | `eval/presend-score.ts`, `eval/bench/` | run `eval/bench/fetch.sh` first |
-
-The order of operations that matters, in one paragraph: when a tool result arrives and is large, build views from the
-text (code, no model), ask jev which view suffices and whether exact text is needed, apply the configured selection
-policy, and optionally expand code blocks in a second request. If a reduced view wins, replace the content with that
-view plus a footer naming `recall`, and keep the full text in result details. Post-send classification then decides
-whether to keep, trim or stub eligible results. Persist and re-apply those decisions to avoid repeated changes to
-already-transformed messages. Never remove a tool result, only rewrite it.
+| the jev questions, the state shape, the decision rule, block expansion | `src/presend.ts` | `@typesafe-ai/sdk` |
+| the parser for bash display commands | `src/shell-display.ts` | nothing |
+| the hook wiring for pi (tool_result, the recall tool, the UI) | `index.ts`, `src/ui.ts` | pi |
+| the benchmark and the metrics on real trajectories | `eval/presend-score.ts`, `eval/bench/` | run `eval/bench/fetch.sh` first |
+| post-send decisions and the frozen ledger | `src/classifier.ts`, `src/policy.ts`, `src/ledger.ts` | `@typesafe-ai/sdk` |
+
+The sequence is this. When a large tool result arrives, code builds the views from the text. jev says which view is
+enough and whether the exact text is needed. Code applies the selection policy. If needed, a second request expands
+blocks or sections. If a reduced view wins, the content becomes that view plus a footer that names `recall`, and the
+full text stays in the details of the result.
 
 ## Contributing and license
 
 Issues and pull requests are welcome at [github.com/dizk/pi-jev-lens](https://github.com/dizk/pi-jev-lens).
-`npm test` runs the unit tests with the mock classifier; `npm run typecheck` runs tsc. Changes to how views are built
-or chosen should come with benchmark numbers (see [Evaluation](#evaluation)); anything that touches code views must be
-scored on the 500-trajectory slice, not only the 100-trajectory holdout, because edit-misses are rare and expensive.
-STATUS.md is the research log: what was tried, what the numbers said, and why the defaults are what they are.
+`npm test` runs the unit tests with the mock classifier. `npm run typecheck` runs tsc. A change to how views are
+built or chosen must come with benchmark numbers. If the change touches code views, you must use the 500-trajectory
+slice.
 
 MIT, see LICENSE.

package/STATUS.md

@@ -383,6 +383,10 @@ The excluded edit results also shrink the editable count from 46 to 26, which is
 
 **Lesson for the research loop.** Every conclusion about code views drawn from the 100-trajectory holdout was drawn from 13 to 15 editable results, and the one that mattered was wrong. Editable results are the scarce evidence; the large slice has 26 after excluding edit echoes, the reserve 800-1299 should have a similar number, and autoresearch should be scored on the large slice for any variant that touches code, even at 20 minutes per evaluation.
 
+## 0.2.0: pre-send only (2026-09-19)
+
+Published as `pi-jev-lens` on npm (the name `pi-jev-context` belongs to an unrelated post-send pruning extension). With the release the extension was cut down to the one layer with evidence behind it: durable notes are removed (never measured, one jev call per user and assistant message, and a surprising thing for a compressor to do), and post-send pruning is off by default (`JEV_LENS_MODE=off`), kept in the code for long sessions where the context budget might matter. Everything above about post-send and notes stays as the record of why.
+
 ## What to try next
 
 1. **Pre-send judgment**: built, see above. Next: let the autoresearch researcher write view builders (one per content kind, sandboxed, verified as strict line subsets) instead of only prompt text and thresholds; three rounds of the latter transferred nothing, every code-built view did. And a structural rule for the second step: expand blocks referenced by an expanded block or named in the task.

package/index.ts

@@ -1,17 +1,13 @@
 /**
- * pi-jev-lens: cache-aware memory routing for pi.
+ * pi-jev-lens: jev picks what the model gets to see of large tool results.
  *
- * Every tool result is classified once by jev (TypeSafe System One) after the agent has
- * seen it and acted on it. The decision (keep / trim / forget, plus durable yes/no) is
- * persisted and, once applied to an outgoing prompt, never changes again, so the prompt
- * prefix stays byte-identical across calls and the provider cache keeps hitting.
+ * Pre-send: before a large tool result is stored or sent, code builds candidate views (strict
+ * subsets of the output with line numbers), jev (TypeSafe System One) chooses one and, for code
+ * and sectioned command output, which blocks to put back. The full text stays in the result's
+ * details and the `recall` tool serves it on request.
  *
- * Buckets:
- *   context (keep)  – sent verbatim
- *   trim            – head + tail only
- *   forget          – replaced by a one-line stub (tool results are never removed:
- *                     every function_call needs a matching output)
- *   file (durable)  – appended to <project>/.pi/jev-lens.md, loaded at session start
+ * Post-send (off by default, JEV_LENS_MODE=rolling|batch|budget): tool results the agent has
+ * already acted on are classified once and trimmed or stubbed behind a frozen, cache-aware ledger.
  */
 import { appendFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
@@ -28,10 +24,9 @@ import { buildPresendState, decideView, DEFAULT_PROMPTS, expandRelevantBlocks, J
 import { buildCandidatesAsync, extractTerms, footer } from "./src/views.ts";
 import { keyFilePath, loadConfigWithVariant, storeKey, type Config } from "./src/config.ts";
 import { ENTRY_TYPE, rebuildLedger } from "./src/ledger.ts";
-import { appendNotes, memoryPromptSection, readMemoryFile } from "./src/memory-file.ts";
 import { applyLedger, decideBucket, pendingPrunable, shouldApplyPending } from "./src/policy.ts";
 import { contentText, describeToolCall, estimateTokensOfText, toolCallsOf, truncate } from "./src/text.ts";
-import type { CallStats, Decision, DurableNote } from "./src/types.ts";
+import type { CallStats, Decision } from "./src/types.ts";
 
 interface PendingResult {
 	message: AgentMessage & { role: "toolResult" };
@@ -64,7 +59,6 @@ export default function (pi: ExtensionAPI) {
 	let ledger = new Map<string, Decision>();
 	/** Classifications launched but not yet resolved, keyed by toolCallId. */
 	const inflight = new Map<string, Promise<void>>();
-	const textInflight = new Set<Promise<void>>();
 	let generation = 0;
 	let sessionAbort = new AbortController();
 	const workSignal = (signal?: AbortSignal) => signal ? AbortSignal.any([signal, sessionAbort.signal]) : sessionAbort.signal;
@@ -81,13 +75,10 @@ export default function (pi: ExtensionAPI) {
 	const argsById = new Map<string, unknown>();
 	let callIndex = 0;
 	let lastCallAt = 0;
-	let memorySnapshot = "";
-	let memoryPath = "";
 	let logPath = "";
-	let totals = { pruned: 0, applied: 0, notes: 0, calls: 0, cacheRead: 0, input: 0 };
+	let totals = { pruned: 0, applied: 0, calls: 0, cacheRead: 0, input: 0 };
 	/** Tokens kept out of the prompt, summed over every LLM call of the session (a compressed result saves on each later call too). */
 	let cut = { presend: 0, pruned: 0 };
-	let durableQueue: DurableNote[] = [];
 	let firstUser = "";
 	let latestUser = "";
 
@@ -108,7 +99,8 @@ export default function (pi: ExtensionAPI) {
 		const tag = usingMock ? "jev-lens(mock)" : "jev-lens";
 		const pct = cutShare();
 		const lead = pct === undefined ? tag : `${tag} −${pct}% of input`;
-		return `${lead} (presend −${(presendTotals.tokensSaved / 1000).toFixed(1)}k · ${presendTotals.compressed}/${presendTotals.considered} · ${presendTotals.recalls} recalls, pruned −${(totals.pruned / 1000).toFixed(1)}k · ${totals.applied}, ${totals.notes} notes)`;
+		const pruned = cfg.mode === "off" ? "" : `, pruned −${(totals.pruned / 1000).toFixed(1)}k · ${totals.applied}`;
+		return `${lead} (presend −${(presendTotals.tokensSaved / 1000).toFixed(1)}k · ${presendTotals.compressed}/${presendTotals.considered} · ${presendTotals.recalls} recalls${pruned})`;
 	};
 	const status = (ctx: ExtensionContext) => {
 		if (!ctx.hasUI) return;
@@ -123,8 +115,6 @@ export default function (pi: ExtensionAPI) {
 		generation++;
 		sessionAbort.abort();
 		sessionAbort = new AbortController();
-		textInflight.clear();
-		durableQueue = [];
 		lastAssistantText = "";
 		ledger = rebuildLedger(ctx.sessionManager.getEntries());
 		buffer = [];
@@ -132,7 +122,7 @@ export default function (pi: ExtensionAPI) {
 		argsById.clear();
 		callIndex = 0;
 		lastCallAt = 0;
-		totals = { pruned: 0, applied: 0, notes: 0, calls: 0, cacheRead: 0, input: 0 };
+		totals = { pruned: 0, applied: 0, calls: 0, cacheRead: 0, input: 0 };
 		cut = { presend: 0, pruned: 0 };
 		firstUser = "";
 		latestUser = "";
@@ -140,8 +130,6 @@ export default function (pi: ExtensionAPI) {
 		records.length = 0;
 		recordById.clear();
 		presendTotals = { considered: 0, compressed: 0, tokensSaved: 0, recalls: 0 };
-		memoryPath = join(ctx.cwd, CONFIG_DIR_NAME, "jev-lens.md");
-		memorySnapshot = readMemoryFile(memoryPath);
 		try {
 			mkdirSync(join(ctx.cwd, CONFIG_DIR_NAME), { recursive: true });
 			logPath = join(ctx.cwd, CONFIG_DIR_NAME, "jev-lens.log");
@@ -170,25 +158,17 @@ export default function (pi: ExtensionAPI) {
 
 	pi.on("session_shutdown", async () => {
 		const epoch = generation;
-		await waitForWork([...inflight.values(), ...textInflight]);
+		await waitForWork([...inflight.values()]);
 		if (epoch !== generation) return;
-		flushDurable();
-		if (inflight.size || textInflight.size) log({ event: "shutdown_timeout", pending: inflight.size + textInflight.size });
+		if (inflight.size) log({ event: "shutdown_timeout", pending: inflight.size });
 		generation++;
 		sessionAbort.abort();
 		inflight.clear();
-		textInflight.clear();
-		durableQueue = [];
 	});
 
-	// ---- memory file → system prompt (snapshot taken at session start, stable within the session)
-
 	pi.on("before_agent_start", async (event) => {
 		if (!firstUser) firstUser = event.prompt;
 		latestUser = event.prompt;
-		const section = memoryPromptSection(memorySnapshot);
-		if (!section) return;
-		return { systemPrompt: event.systemPrompt + section };
 	});
 
 	// ---- classification ------------------------------------------------------------------
@@ -199,7 +179,6 @@ export default function (pi: ExtensionAPI) {
 			const text = contentText(m.content);
 			if (!firstUser) firstUser = text;
 			latestUser = text;
-			queueText("user", text, ctx);
 			return;
 		}
 		if (m.role === "toolResult") {
@@ -214,7 +193,6 @@ export default function (pi: ExtensionAPI) {
 		const toClassify = buffer;
 		buffer = [];
 		for (const item of toClassify) launchClassification(item, afterText, afterCalls, ctx);
-		if (afterText.trim()) queueText("agent", afterText, ctx);
 	});
 
 	pi.on("tool_execution_end", async (event) => {
@@ -234,13 +212,13 @@ export default function (pi: ExtensionAPI) {
 		const toClassify = buffer;
 		buffer = [];
 		for (const item of toClassify) launchClassification(item, "", [], undefined);
-		await waitForWork([...inflight.values(), ...textInflight]);
-		if (epoch === generation) flushDurable();
+		await waitForWork([...inflight.values()]);
+		void epoch;
 	});
 
 	function launchClassification(item: PendingResult, afterText: string, afterCalls: { name: string; arguments: unknown }[], ctx?: ExtensionContext) {
 		const m = item.message;
-		if (sessionAbort.signal.aborted || m.content.some((c) => c.type !== "text")) return;
+		if (cfg.mode === "off" || sessionAbort.signal.aborted || m.content.some((c) => c.type !== "text")) return;
 		const epoch = generation;
 		if (ledger.has(m.toolCallId) || inflight.has(m.toolCallId)) return;
 		const output = contentText(m.content);
@@ -267,7 +245,6 @@ export default function (pi: ExtensionAPI) {
 					id: m.toolCallId,
 					toolName: m.toolName,
 					bucket: cfg.enabled ? decideBucket(probs, cfg) : "keep",
-					durable: probs.durable > cfg.durableAbove,
 					p: probs,
 					summary,
 					tokensBefore: tokens,
@@ -277,11 +254,6 @@ export default function (pi: ExtensionAPI) {
 				ledger.set(decision.id, decision);
 				persist(decision);
 				log({ event: "decision", id: decision.id, tool: m.toolName, bucket: decision.bucket, p: probs, tokens, ms: Date.now() - started, summary });
-				// Tool output is rarely a durable fact by itself; only keep a pointer, and only when jev is very sure.
-				if (probs.durable > Math.max(cfg.durableAbove, 0.85)) {
-					durableQueue.push({ source: "tool", text: `${summary}${m.isError ? " failed" : " succeeded"}`, p: probs.durable, at: Date.now() });
-					flushDurable();
-				}
 			})
 			.catch((err) => {
 				if (epoch === generation) log({ event: "classify_error", id: m.toolCallId, error: String(err?.message ?? err) });
@@ -290,37 +262,6 @@ export default function (pi: ExtensionAPI) {
 		inflight.set(m.toolCallId, p);
 	}
 
-	function queueText(role: "user" | "agent", text: string, ctx?: ExtensionContext) {
-		if (sessionAbort.signal.aborted || usingMock || text.length < 40 || text.length > 6000) return;
-		const epoch = generation;
-		const work = classifier
-			.classifyText({ task: { first_user_request: truncate(firstUser, 600) }, message: truncate(text, 3000), role }, workSignal(ctx?.signal))
-			.then((p) => {
-				if (epoch !== generation) return;
-				log({ event: "text", role, p, chars: text.length });
-				if (p > cfg.durableAbove) {
-					durableQueue.push({ source: role, text: truncate(text, 400), p, at: Date.now() });
-					flushDurable();
-				}
-			})
-			.catch((err) => { if (epoch === generation) log({ event: "classify_error", role, error: String(err?.message ?? err) }); })
-			.finally(() => { if (epoch === generation) textInflight.delete(work); });
-		textInflight.add(work);
-	}
-
-	function flushDurable() {
-		if (durableQueue.length === 0 || !memoryPath) return;
-		const notes = durableQueue;
-		durableQueue = [];
-		try {
-			const added = appendNotes(memoryPath, notes);
-			totals.notes += added;
-			log({ event: "memory_file", added, path: memoryPath });
-		} catch (err) {
-			log({ event: "memory_file_error", error: String((err as Error)?.message ?? err) });
-		}
-	}
-
 	// ---- the cache-aware cut: right before each LLM call --------------------------------
 
 	pi.on("context", async (event, ctx) => {
@@ -392,7 +333,6 @@ export default function (pi: ExtensionAPI) {
 				persist(d);
 			}
 		}
-		flushDurable();
 	});
 
 	// ---- pre-send compression: pick a view of a large tool result before it is ever sent ----
@@ -535,7 +475,7 @@ export default function (pi: ExtensionAPI) {
 	// ---- commands ----------------------------------------------------------------------
 
 	pi.registerCommand("jev-lens", {
-		description: "jev-lens: stats | list (compressed results) | diff [n] (original vs sent, overlay) | decisions | file | key [api-key] (store your TypeSafe key)",
+		description: "jev-lens: stats | list (compressed results) | diff [n] (original vs sent, overlay) | decisions | key [api-key] (store your TypeSafe key)",
 		handler: async (args, ctx) => {
 			const sub = (args ?? "").trim();
 			if (sub === "key" || sub.startsWith("key ")) {
@@ -548,11 +488,6 @@ export default function (pi: ExtensionAPI) {
 				status(ctx);
 				return;
 			}
-			if (sub === "file") {
-				const text = readMemoryFile(memoryPath) || "(memory file is empty)";
-				ctx.ui.notify(text, "info");
-				return;
-			}
 			if (sub.startsWith("diff")) {
 				const n = Number(sub.slice(4).trim() || "1");
 				const rec = records[records.length - (Number.isFinite(n) && n >= 1 ? n : 1)];
@@ -570,7 +505,7 @@ export default function (pi: ExtensionAPI) {
 				return;
 			}
 			if (sub === "decisions") {
-				const rows = [...ledger.values()].map((d) => `${d.status === "applied" ? "●" : "○"} ${d.bucket.padEnd(6)} n=${d.p.needed.toFixed(2)} o=${d.p.outcomeOnly.toFixed(2)} d=${d.p.durable.toFixed(2)} ${d.tokensBefore}t ${d.summary}`);
+				const rows = [...ledger.values()].map((d) => `${d.status === "applied" ? "●" : "○"} ${d.bucket.padEnd(6)} n=${d.p.needed.toFixed(2)} o=${d.p.outcomeOnly.toFixed(2)} ${d.tokensBefore}t ${d.summary}`);
 				ctx.ui.notify(rows.join("\n") || "(no decisions yet)", "info");
 				return;
 			}
@@ -582,7 +517,6 @@ export default function (pi: ExtensionAPI) {
 					`post-send: calls=${totals.calls} decisions=${ledger.size} applied=${totals.applied} pruned≈${totals.pruned} tokens`,
 					`cache: read=${totals.cacheRead} uncached=${totals.input} hit=${hit}%`,
 					`input cut: ${cutShare() ?? 0}% of the session's input tokens (≈${cut.presend + cut.pruned} of ${totals.input + totals.cacheRead + cut.presend + cut.pruned}: presend ${cut.presend}, pruned ${cut.pruned}, summed over ${totals.calls} calls)`,
-					`memory file: ${memoryPath} (+${totals.notes} notes this session)`,
 				].join("\n"),
 				"info",
 			);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-jev-lens",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "pi extension that compresses large tool results before they reach the model: jev picks the view (outline, relevant blocks, sections, signals, testlog), full text stays recallable",
   "author": "Didrik Rognstad",
   "license": "MIT",

package/src/classifier.ts

@@ -28,7 +28,6 @@ export interface TextState {
 
 export interface Classifier {
 	classifyToolResult(state: ItemState, signal?: AbortSignal): Promise<Probabilities>;
-	classifyText(state: TextState, signal?: AbortSignal): Promise<number>;
 }
 
 export function buildItemState(
@@ -83,36 +82,6 @@ export const TOOL_RESULT_QUESTIONS = {
 			false: "Source code, file contents, search results, directory listings, or any output where specific lines in the middle carry the information.",
 		},
 	},
-	durable: {
-		type: "noul" as const,
-		instructions:
-			"Does `item` reveal a stable fact about this project (its structure, conventions, how to build, test or run it, a known pitfall) or about the user's preferences, that would still be true and useful in a future, unrelated session?",
-		criteria: {
-			true: "Build or test commands that work, project layout, conventions, configuration quirks, recurring gotchas.",
-			false: "Task-specific content, transient state, one-off command output, file contents that change with every edit.",
-		},
-	},
-};
-
-export const TEXT_QUESTIONS = {
-	durable_user: {
-		type: "noul" as const,
-		instructions:
-			"`message` was written by the user to a coding agent. Does it state a preference, standing instruction, or fact about the user or the project that should be remembered in future sessions, rather than a one-off task instruction?",
-		criteria: {
-			true: "Coding style preferences, tools or workflows the user wants used, facts about the project's purpose, constraints that will keep applying.",
-			false: "A task for right now, a question, feedback about one specific change, small talk.",
-		},
-	},
-	durable_agent: {
-		type: "noul" as const,
-		instructions:
-			"`message` was written by a coding agent. Does it state a conclusion, decision, or discovered fact about the project that will remain true and be useful in future unrelated sessions?",
-		criteria: {
-			true: "How the project is structured, where things live, what command runs the tests, a root cause that explains recurring behaviour, a design decision that was made.",
-			false: "Progress narration, a plan for the current task, a question to the user, a summary of edits just made.",
-		},
-	},
 };
 
 export class JevClassifier implements Classifier {
@@ -124,12 +93,7 @@ export class JevClassifier implements Classifier {
 	}
 	async classifyToolResult(state: ItemState, signal?: AbortSignal): Promise<Probabilities> {
 		const r = await this.client.systemOne({ state: state as never, questions: TOOL_RESULT_QUESTIONS, model: this.model }, { signal, timeout: 15000 });
-		return { needed: r.answers.needed.noul, outcomeOnly: r.answers.outcome_only.noul, durable: r.answers.durable.noul };
-	}
-	async classifyText(state: TextState, signal?: AbortSignal): Promise<number> {
-		const q = state.role === "user" ? { durable: TEXT_QUESTIONS.durable_user } : { durable: TEXT_QUESTIONS.durable_agent };
-		const r = await this.client.systemOne({ state: { task: state.task, message: state.message }, questions: q, model: this.model }, { signal, timeout: 15000 });
-		return r.answers.durable.noul;
+		return { needed: r.answers.needed.noul, outcomeOnly: r.answers.outcome_only.noul };
 	}
 }
 
@@ -139,13 +103,10 @@ export class MockClassifier implements Classifier {
 	async classifyToolResult(state: ItemState): Promise<Probabilities> {
 		return this.rule(state);
 	}
-	async classifyText(): Promise<number> {
-		return 0;
-	}
 }
 
 export function defaultMockRule(state: ItemState): Probabilities {
 	const big = state.item.total_chars > 2000;
 	const cmd = state.item.tool === "bash";
-	return { needed: big ? 0.1 : 0.9, outcomeOnly: cmd ? 0.9 : 0.1, durable: 0 };
+	return { needed: big ? 0.1 : 0.9, outcomeOnly: cmd ? 0.9 : 0.1 };
 }

package/src/config.ts

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
-export type SealMode = "rolling" | "batch" | "budget";
+export type SealMode = "off" | "rolling" | "batch" | "budget";
 
 export interface Config {
 	/** Disable all pruning (classification still runs and logs). */
@@ -23,8 +23,6 @@ export interface Config {
 	/** P(needed) below this and P(outcomeOnly) above trimAbove → trim to head+tail. */
 	trimBelow: number;
 	trimAbove: number;
-	/** P(durable) above this → written to the memory file. */
-	durableAbove: number;
 	/** Tool results smaller than this (estimated tokens) are never touched. */
 	minTokens: number;
 	/** Maximum wait for in-flight classifications at context, agent end and shutdown. */
@@ -125,7 +123,7 @@ function num(name: string, fallback: number): number {
 export function loadConfig(): Config {
 	loadDotEnv();
 	const envMode = process.env.JEV_LENS_MODE;
-	const mode: SealMode = envMode === "batch" || envMode === "budget" || envMode === "rolling" ? envMode : "budget";
+	const mode: SealMode = envMode === "batch" || envMode === "budget" || envMode === "rolling" ? envMode : "off";
 	return {
 		enabled: process.env.JEV_LENS_DISABLED !== "1",
 		mode,
@@ -134,7 +132,6 @@ export function loadConfig(): Config {
 		forgetBelow: num("JEV_LENS_FORGET_BELOW", 0.25),
 		trimBelow: num("JEV_LENS_TRIM_BELOW", 0.5),
 		trimAbove: num("JEV_LENS_TRIM_ABOVE", 0.6),
-		durableAbove: num("JEV_LENS_DURABLE_ABOVE", 0.7),
 		minTokens: num("JEV_LENS_MIN_TOKENS", 150),
 		classifyWaitMs: num("JEV_LENS_CLASSIFY_WAIT_MS", 2500),
 		cacheTtlMs: num("JEV_LENS_CACHE_TTL_MS", 5 * 60 * 1000),

package/src/types.ts

@@ -3,7 +3,6 @@ export type Bucket = "keep" | "trim" | "forget";
 export interface Probabilities {
 	needed: number;
 	outcomeOnly: number;
-	durable: number;
 }
 
 export interface Decision {
@@ -11,7 +10,6 @@ export interface Decision {
 	id: string;
 	toolName: string;
 	bucket: Bucket;
-	durable: boolean;
 	p: Probabilities;
 	/** One-line description used in the stub, fixed at decision time so the stub never changes. */
 	summary: string;
@@ -24,13 +22,6 @@ export interface Decision {
 	appliedReason?: string;
 }
 
-export interface DurableNote {
-	source: "user" | "agent" | "tool";
-	text: string;
-	p: number;
-	at: number;
-}
-
 export interface CallStats {
 	call: number;
 	at: number;

package/src/memory-file.ts

@@ -1,51 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-import type { DurableNote } from "./types.ts";
-
-export const MEMORY_MAX_LINES = 150;
-export const MEMORY_MAX_CHARS = 8000;
-
-function hash(s: string): string {
-	let h = 0;
-	for (let i = 0; i < s.length; i++) h = (Math.imul(31, h) + s.charCodeAt(i)) | 0;
-	return (h >>> 0).toString(16);
-}
-
-export function readMemoryFile(path: string): string {
-	return existsSync(path) ? readFileSync(path, "utf8") : "";
-}
-
-/** Append durable notes as bullet lines, dedup by normalized text, cap size keeping the newest. */
-export function appendNotes(path: string, notes: DurableNote[]): number {
-	if (notes.length === 0) return 0;
-	const existing = readMemoryFile(path);
-	const lines = existing.split("\n").filter((l) => l.startsWith("- "));
-	const seen = new Set(lines.map((l) => hash(l.replace(/^- \(\S+, \w+\) /, "").trim().toLowerCase())));
-	let added = 0;
-	for (const n of notes) {
-		const text = n.text.replace(/\s+/g, " ").trim();
-		if (!text) continue;
-		const key = hash(text.toLowerCase());
-		if (seen.has(key)) continue;
-		seen.add(key);
-		const date = new Date(n.at).toISOString().slice(0, 10);
-		lines.push(`- (${date}, ${n.source}) ${text.length > 400 ? `${text.slice(0, 400)}…` : text}`);
-		added++;
-	}
-	if (added === 0) return 0;
-	let kept = lines.slice(-MEMORY_MAX_LINES);
-	while (kept.join("\n").length > MEMORY_MAX_CHARS && kept.length > 1) kept = kept.slice(1);
-	const header = "# jev-lens\n\nDurable notes selected by jev from earlier sessions. Newest last.\n\n";
-	mkdirSync(dirname(path), { recursive: true });
-	writeFileSync(path, `${header}${kept.join("\n")}\n`, "utf8");
-	return added;
-}
-
-export function memoryPromptSection(snapshot: string): string {
-	const body = snapshot
-		.split("\n")
-		.filter((l) => l.startsWith("- "))
-		.join("\n");
-	if (!body) return "";
-	return `\n\n# Memory from earlier sessions (jev-lens)\nThese notes were kept from previous sessions in this project. Treat them as likely but verify before relying on details.\n${body}\n`;
-}