@chroxify/eunoe 1.3.0 → 1.3.1

package/README.md

@@ -243,7 +243,10 @@ a small and very fast model, reorders the top 30 in about 300 ms, which
 lifted the right excerpt from 88% to 95% of questions and beat every other
 method and model that was tested. Without a key the BM25 order is used and
 nothing else changes. The recall is computed once per message and pinned to
-it, so it never disturbs the cache.
+it, so it never disturbs the cache. Once that message is folded its recall is
+dropped with it, and the recall on the messages still in context stays under
+30K characters in total and under a quarter of the context (with a 6K floor),
+so it never crowds out the conversation itself.
 
 ## How it plugs in
 
@@ -504,21 +507,22 @@ output stays byte-stable from one request to the next.
 Every call returns a note: `action` (`pass`, `full` or `compact`),
 `cutTurn`, `folded`, `omitted`, `pinned`, `estimate` in tokens, `fit` when
 the request had to be trimmed to fit (`recut`, `bare` or `over`), and
-`stuck` when even the cut leaves it over its target. `stuck` gives the
+`stuck` when even the cut leaves it over the limit. `stuck` gives the
 tokens in each part (`fixed`, `head`, `folded`, `live`) so the host can
 act: start a fresh conversation with a handoff, or fold at its own
-boundary. While a thread is stuck, eunoe holds what it cleared still
-instead of clearing a little more on every request, so the cache keeps
-hitting.
+boundary. It clears as soon as a request fits. While a thread is stuck,
+eunoe holds what it cleared still instead of clearing a little more on
+every request, and clears again only when that makes the request fit or
+brings it back under the window, so the cache keeps hitting.
 
 ### The whole proxy as one call
 
 `createForwarder` is the proxy's request loop as a fetch handler: it
 rewrites each `/v1/messages` request, forwards everything to the API,
 streams the answer back, learns the thread's real token ratio from the
-answer's `usage`, retries once with a corrected size after a "prompt is
-too long", retries a stalled `count_tokens`, and looks the context window
-up from the Models API. `eunoe serve` is this call with a file-backed
+answer's `usage`, retries once after a "prompt is too long" against the
+limit the error names (and keeps that limit for the thread and model), retries a
+stalled `count_tokens`, and looks the context window up from the Models API. `eunoe serve` is this call with a file-backed
 store, Claude Code's session files as sources and a request log.
 
 ```ts
@@ -541,7 +545,7 @@ that calls the API itself gets the same calibration with
 | `foldThread`, `pinTurns` | fold at your own boundary, keep chosen turns whole |
 | `createForwarder` | the full proxy loop as a `(Request) => Promise<Response>` |
 | `recordUsage`, `recordOverflow` | feed what the API said back into the thread's estimates |
-| `createWindowLookup` | a model's context window from the Models API, cached |
+| `createWindowLookup` | a model's context window from the Models API, cached, with a per-family fallback |
 | `memoryStore`, `threadKeyOf` | in-memory state, and the key a thread is saved under |
 | `listSubagentRecall` | recall over what your own subagents printed |
 | `renderTranscriptFiles`, `transcriptGuide` | the searchable per-turn transcript from your own messages, and the text that points the agent at it |
@@ -587,9 +591,12 @@ at each step and keeps its plan pinned, and a
   finds the deploy output, but ask about "that thing from before" and it
   finds nothing, leaving the agent to search the transcript itself. Jev
   narrows this gap without closing it.
-- **It never cuts against a limit it can't verify.** The context window size
-  comes from the Models API for each model, and if that lookup fails the
-  budget folds still happen but the full cut does not.
+- **The window can be a guess.** The context window size comes from the
+  Models API for each model. When that lookup fails or takes over 1.5 s,
+  eunoe assumes the model family's window (1M for Claude 5 models, Opus
+  4.8 and `[1m]` ids, 200K for other Claude models) and asks again ten
+  minutes later. A guess that is too big is caught by the "prompt is too
+  long" retry, which then keeps the real limit for that thread and model.
 
 ## Credits