@giovannijecha/jecode 0.8.1 → 0.8.3

package/README.md

@@ -1,9 +1,9 @@
 <p align="center">
-  <img src="docs/assets/brand/jeco-256.png" width="128" alt="Jeco, the steel-blue Jecode gecko">
+  <img src="assets/jeco-256.png" width="128" alt="Jeco, the steel-blue Jecode gecko">
 </p>
 
 <p align="center">
-  <img src="docs/assets/brand/wordmark-steel.svg" width="280" alt="Jecode">
+  <img src="assets/wordmark-steel.svg" width="280" alt="Jecode">
 </p>
 
 <p align="center"><strong>Your code. Your loop.</strong></p>
@@ -22,35 +22,26 @@
 
 <p align="center">
   <a href="https://github.com/giovannijecha/jecode/blob/main/CHANGELOG.md">Changelog</a> &middot;
-  <a href="https://github.com/giovannijecha/jecode/blob/main/docs/compatibility.md">Compatibility</a> &middot;
+  <a href="https://github.com/giovannijecha/jecode/blob/main/docs/COMPATIBILITY.md">Compatibility</a> &middot;
   <a href="https://github.com/giovannijecha/jecode/releases">Releases</a>
 </p>
 
 > Jecode is currently pre-1.0. The core loop is usable today, but commands and
 > terminal interactions may still evolve before 1.0. The release-candidate
-> surface is now frozen in the [compatibility contract](https://github.com/giovannijecha/jecode/blob/main/docs/compatibility.md).
+> surface is now frozen in the [compatibility contract](https://github.com/giovannijecha/jecode/blob/main/docs/COMPATIBILITY.md).
 
 ## Why Jecode
 
-- **One visible loop.** One controller talks to the model, runs tools, and
-  returns control to you. Independent reads may overlap within one model
-  response; writes and commands stay ordered. You can steer an active turn
-  without starting a second loop. There are no delegated agents or hidden
-  model workers.
-- **Terminal-native today.** The transcript, composer, searchable menus, tool
-  output, diffs, approvals, reasoning, and status share one full-screen TUI.
-- **Permission-aware.** Tool use is visible. Dangerous actions ask first, and
-  remembered session approvals can be reviewed or revoked.
-- **Durable and context-bounded.** Interactive conversations survive terminal
-  exits. Older model context can be compacted while the complete conversation
-  and transcript remain available in the saved session.
-- **Multi-provider.** Use Anthropic or OpenAI API keys, an eligible ChatGPT
-  account, or a local, cloud, or remote Ollama server without changing the
-  workflow.
-- **Lean by construction.** Jecode ships as owned JavaScript built on Node.js
-  primitives, executes no installation scripts, and has zero third-party
-  runtime dependencies. This is a permanent product constraint, not a temporary
-  optimization.
+Jecode keeps the coding loop yours. Work stays in one terminal where you can
+follow tool calls and diffs, steer the model while it runs, and resume the same
+conversation later. One controller carries each turn from prompt to result—no
+delegated agents or hidden model workers.
+
+Choose Anthropic, OpenAI, an eligible ChatGPT account, or Ollama without
+changing the workflow. Jecode is written in TypeScript and released as plain
+JavaScript for Node.js, with no installation scripts and zero third-party
+runtime dependencies. The runtime stays small enough to inspect, understand,
+and change.
 
 ## Quick start
 
@@ -73,13 +64,7 @@ jecode --version
 
 ### Start Jecode
 
-Open the project you want Jecode to work on:
-
-```console
-cd path/to/your/project
-```
-
-Then start Jecode:
+Open the project directory you want Jecode to work on, then start Jecode:
 
 ```console
 jecode
@@ -118,16 +103,6 @@ jecode --help
 
 Windows, Ubuntu, and macOS are covered by the project test matrix.
 
-### Prereleases
-
-Prereleases exist only during an announced release-candidate cycle. When one is
-active, its GitHub release provides the exact installation command. Outside an
-active cycle, the stable npm package is the only supported installation
-artifact.
-
-Git URL installs are intentionally unsupported: the source tree contains no
-generated runtime and defines no install-time build hook.
-
 ### Uninstall
 
 ```console
@@ -138,23 +113,6 @@ Uninstalling the command preserves `~/.jecode`. Remove that directory only when
 you intentionally want to erase saved settings, credentials, accounts, and
 sessions.
 
-### Replace a legacy installation
-
-If an older GitHub installation still owns the `jecode` executable, first
-remove the legacy unscoped package:
-
-```console
-npm uninstall --global jecode
-```
-
-Then install the current scoped package:
-
-```console
-npm install --global @giovannijecha/jecode@latest
-```
-
-Do not work around the resulting `EEXIST` error with `--force`.
-
 ### Linux and WSL
 
 WSL uses its own Node.js installation and `PATH`; the Node.js version installed
@@ -200,228 +158,11 @@ WSL, `command -v jecode` should resolve below `/home/...`, not through an
 inherited Windows path below `/mnt/c`. Do not ignore `EBADENGINE`: `node
 --version` must report 22.18+ on the 22.x line, or 24+.
 
-## Providers
-
-| Provider ID | Authentication | Notes |
-| --- | --- | --- |
-| `anthropic` | `ANTHROPIC_API_KEY` | Anthropic API |
-| `openai` | `OPENAI_API_KEY` | OpenAI API |
-| `openai-codex` | ChatGPT OAuth | Experimental; uses eligible ChatGPT Codex access |
-| `ollama` | `OLLAMA_API_KEY` for cloud or remote use | Cloud with a key, local without one |
-
-Choose **ChatGPT** in `/providers` to sign in on OpenAI's website without
-pasting a key. Jecode supports a local browser callback and a device-code flow;
-WSL and remote terminals default to the device code. Availability and usage
-limits depend on the ChatGPT account and plan, not on OpenAI API credits. This
-integration is experimental and is not an endorsement of Jecode by OpenAI.
-
-Anthropic remains API-key only. Jecode does not reuse a Claude consumer
-subscription or copy credentials from another client.
-
-For Ollama, `/providers` can select cloud, local, or a custom endpoint. With an
-Ollama API key Jecode defaults to `https://ollama.com`; without one it defaults
-to `http://127.0.0.1:11434`. Remote custom endpoints must use HTTPS.
-
-## Use the TUI
-
-Type `/` to open searchable command completion inside the composer.
-
-| Command | What it does |
-| --- | --- |
-| `/settings` | Manage the selected model and saved non-secret defaults |
-| `/effort` | Change and save reasoning effort directly |
-| `/providers` | Manage provider connections, API keys, ChatGPT sign-in, and Ollama endpoints |
-| `/models` | Search all currently usable provider catalogues and select a model |
-| `/permissions` | Change session tool access and review remembered approvals |
-| `/timeline` | Browse resumable turns and select where the next branch should begin |
-| `/compact` | Compact the current branch context without deleting saved conversation history |
-| `/new` | Start a new conversation and reset session tool permissions |
-| `/export` | Save a timestamped Markdown transcript in the launch directory |
-| `/help` | Open a temporary keyboard reference in the composer dock |
-| `/exit` | Restore the terminal and exit |
-
-Useful controls:
-
-- **Up/Down** moves through suggestions, menus, and input history.
-- **Left/Right** moves the cursor or changes an inline value;
-  **Ctrl+Left/Right** moves by word.
-- **Backspace/Delete** removes one character;
-  **Ctrl+Backspace/Delete** removes one word.
-- **Home/End** moves to the beginning or end of the composer.
-- **Tab** completes a slash command without running it; **Enter** sends. During
-  an active model turn, **Enter** queues guidance for its next safe boundary.
-- **Alt+Enter** inserts a newline.
-- **Esc** closes the active menu or interrupts foreground work.
-- **Ctrl+C** interrupts, or exits while idle. **Ctrl+D** requests a clean exit.
-- **PageUp/PageDown** and the mouse wheel scroll the transcript.
-- **Ctrl+O** expands or compacts the latest reasoning or tool-detail block.
-
-The footer keeps the active model, effort, and workspace visible. During work,
-it adds the current state, elapsed time, steering availability or queue count,
-and interrupt hint. Queued guidance joins the same conversation turn after the
-provider response or complete tool batch already in progress; `Esc` remains an
-immediate interruption. Operational feedback uses the same replaceable status
-area instead of adding noise to the conversation or its Markdown export.
-
-## Sessions and context
-
-Interactive conversations are stored under `~/.jecode/sessions` and scoped to
-the canonical workspace path. A fresh or `/new` conversation is not added to
-the resume picker until it has a settled turn. Resuming and continuing a
-conversation keeps its durable session identity and updates one picker entry
-instead of creating duplicates.
-
-`/timeline` shows completed, failed, and interrupted turns in the conversation
-tree. Selecting an older turn changes only the in-memory path: it creates and
-saves a branch only after the next real user message. Cancelling the picker or
-exiting before that message leaves the durable head unchanged. A failed turn
-keeps the same partial evidence and outcome in the live transcript, export, and
-resume, while the next model receives a neutral failure boundary instead of
-incomplete streamed text. Historical tools are displayed but never executed.
-If a process stops abruptly inside a tool loop, Jecode resumes from the latest
-safe ancestor and lets the next user turn create a branch. `/export` writes
-only the currently selected path.
-
-When model-facing context approaches the selected model's usable capacity,
-Jecode asks the provider for a bounded summary of the older prefix and keeps
-recent turns exact. The default trigger is 85% and can be changed from 50% to
-95%. Live provider metadata or Ollama's allocated context determines the budget
-when available; provider safety limits always win.
-
-Compaction changes only the projection sent to the model. Complete messages,
-tool evidence, transcript, export, and conversation tree remain intact. The
-branch-local summary anchor is saved with the session so resume does not repeat
-the same compaction. `/compact` requests this process immediately, even below
-the automatic threshold; it leaves very small contexts unchanged. After
-selecting a historical turn, send the first new message before compacting so
-shared history is never rewritten.
-
-## Batch mode
-
-When stdin or stdout is not a terminal, Jecode switches to a plain
-line-oriented mode:
-
-```console
-printf "explain this project\n" | jecode --root .
-```
-
-Batch conversations are stateless. Dangerous tools remain denied unless
-`--auto-approve` is supplied explicitly. Terminal failures are written to
-stderr and exit non-zero so scripts and CI pipelines can stop reliably.
-
-## Configuration
-
-Startup precedence is: command-line flags, environment variables, saved
-settings, then built-in defaults.
-
-| Flag | Environment | Default |
-| --- | --- | --- |
-| `--provider` | `JECODE_PROVIDER` | `anthropic` |
-| `--model` | `JECODE_MODEL` | Provider default or interactive selection |
-| `--ollama-host` | `OLLAMA_HOST` | Cloud with an Ollama key, local without one |
-| `--root` | - | Current directory |
-| `--effort` | `JECODE_EFFORT` | `high` |
-| `--max-tokens` | `JECODE_MAX_TOKENS` | `64000` ceiling, clamped to the usable request budget; not sent by `openai-codex` |
-| `--max-steps` | `JECODE_MAX_STEPS` | No limit |
-| `--compaction-percent` | `JECODE_COMPACTION_PERCENT` | `85`; accepts `50` through `95` |
-| `--reduced-motion` | `JECODE_REDUCED_MOTION=1` | Off |
-| `--auto-approve` | `JECODE_AUTO_APPROVE=1` | Off |
-| `--ephemeral` | `JECODE_EPHEMERAL=1` | Off |
-
-`--max-steps` is an opt-in, process-only budget for deterministic automation
-and diagnostics. Interactive work has no arbitrary model-loop ceiling, and the
-budget is neither shown nor saved by `/settings`.
-
-Non-secret preferences live in `~/.jecode/settings.json`. Explicitly saved API
-keys live in `~/.jecode/credentials.json`, while ChatGPT OAuth accounts live in
-`~/.jecode/accounts.json`. Environment credentials always take precedence.
-Secret stores use owner-only permissions where the operating system supports
-them.
-
-Jecode has one current interface theme, Slate. `NO_COLOR` is supported for
-terminals and pipelines that disable colour.
-
-## Safety model
-
-Jecode treats model output, workspace content, tool output, and terminal text as
-untrusted data.
-
-- Current filesystem tools are confined to the selected workspace. Writes
-  reject symlink and junction components, revalidate boundaries and the
-  approved file state immediately before atomic replacement.
-- Dangerous tools ask by default unless explicitly allowed for the session or
-  the process starts with `--auto-approve`.
-- Credential fields are masked and excluded from transcripts. Recognized
-  credential values are redacted before output reaches the model, screen,
-  history, or export.
-- Approved shell commands receive no secret-bearing environment variables.
-  `SSH_AUTH_SOCK` is preserved so Git and SSH can use the user's agent, which
-  means an approved command may ask that agent to authenticate.
-- ChatGPT OAuth uses PKCE and an exact loopback callback or the OpenAI device
-  flow. Refresh-token rotation is serialized across Jecode processes.
-- Terminal control characters are neutralized before rendering.
-- Remote Ollama endpoints require HTTPS, and provider redirects are rejected.
-- Provider handshakes and idle response bodies have finite deadlines. Only
-  idempotent catalogue reads retry; generation requests are never replayed.
-- Model, terminal, and filesystem input are bounded before use.
-- Session files are versioned, symmetrically size-bounded before write and
-  after read, atomically checkpointed, and treated as untrusted when loaded. A
-  live lease prevents concurrent resume.
-
-`run_command` is not an operating-system sandbox. An approved command can still
-access files and account resources available to the current user. Review
-commands carefully and reserve `--auto-approve` for controlled environments.
-
-Read [SECURITY.md](SECURITY.md) before reporting a vulnerability.
-
-## Project direction
-
-The terminal is Jecode's current primary interface, not the limit of the
-product. Future interfaces may reuse the same controller, session model, and
-visible control system. Expansion must remain deliberate: no hidden model
-hierarchy, no delegated authority, and no weakening of the zero-dependency
-runtime.
-
-The single-controller rule limits delegation, not duration or scope. Jecode may
-eventually supervise visible, interruptible processes such as development
-servers, file watchers, and test runners. Those processes remain tools owned by
-the controller; they do not receive independent goals, model loops, or tool
-authority.
-
-The selected workspace is the current default filesystem boundary. Any future
-access to additional directories or resources must use explicit, reviewable,
-revocable grants rather than silently widening that boundary.
-
-## Build from source
-
-```console
-git clone https://github.com/giovannijecha/jecode.git
-cd jecode
-npm ci --ignore-scripts
-npm run build:release
-npm link
-jecode --version
-```
-
-Development runs TypeScript directly with `npm run start`. `dist/` is an
-ignored generated tree used only by linked commands and release tarballs.
-`npm run pack:release` rebuilds it from a clean target. Installing the published
-package runs no compilation or installation scripts.
-
-Run the complete project checks with:
-
-```console
-npm run check
-```
+## Documentation
 
-Use `npm run tui:lab` to inspect production TUI components with inert local
-fixtures. `npm run bench:transcript` and `npm run bench:search` provide manual
-probes for long-session rendering and workspace search. Architecture and
-security boundaries are documented in
-[docs/architecture.md](docs/architecture.md); brand assets and usage rules live
-in [docs/brand.md](docs/brand.md). The public 1.0 contract lives in
-[docs/compatibility.md](docs/compatibility.md), and the maintainer release
-procedure lives in [docs/releasing.md](docs/releasing.md).
+The [user guide](https://github.com/giovannijecha/jecode/blob/main/docs/USAGE.md)
+covers provider access, TUI controls, sessions and compaction, batch mode,
+configuration, and safety boundaries.
 
 ## Community
 

package/dist/accounts.js

@@ -1,10 +1,10 @@
 // OAuth accounts persisted under ~/.jecode, apart from API keys.
 import { chmod, mkdir } from "node:fs/promises";
-import { readFileSync } from "node:fs";
 import * as path from "node:path";
 import { atomicWrite } from "./atomic.js";
 import { withStoreLock } from "./store-lock.js";
 import { userDataLabel, userDataPath } from "./user-data.js";
+import { assertStoreText, readBoundedJsonSync, USER_STORE_LIMITS } from "./user-store.js";
 let cached;
 export function openAICodexAccount() {
     const account = store().accounts["openai-codex"];
@@ -39,15 +39,20 @@ export async function updateOpenAICodexAccount(change, signal) {
     return withStoreLock(file, async () => {
         const current = readStore(file);
         const next = await change(current.accounts["openai-codex"]);
+        const normalized = next === undefined ? undefined : normalizeOpenAI(next);
+        if (next !== undefined && normalized === undefined)
+            throw new Error("invalid OpenAI account");
         const accounts = { ...current.accounts };
         if (next === undefined)
             delete accounts["openai-codex"];
         else
-            accounts["openai-codex"] = { ...next };
+            accounts["openai-codex"] = normalized;
         const updated = { version: 1, accounts };
-        await atomicWrite(file, `${JSON.stringify(updated, null, 2)}\n`, { mode: 0o600 });
+        const text = `${JSON.stringify(updated, null, 2)}\n`;
+        assertStoreText(text, USER_STORE_LIMITS.accountsBytes);
+        await atomicWrite(file, text, { mode: 0o600 });
         cached = updated;
-        return next === undefined ? undefined : { ...next };
+        return normalized === undefined ? undefined : { ...normalized };
     }, signal);
 }
 export function reloadAccounts() {
@@ -60,8 +65,7 @@ function store() {
 }
 function readStore(file) {
     try {
-        const parsed = JSON.parse(readFileSync(file, "utf8"));
-        return normalize(parsed);
+        return normalize(readBoundedJsonSync(file, USER_STORE_LIMITS.accountsBytes));
     }
     catch {
         return { version: 1, accounts: {} };
@@ -80,9 +84,9 @@ function normalize(value) {
 function normalizeOpenAI(value) {
     if (!record(value))
         return undefined;
-    const accessToken = nonempty(value["accessToken"]);
-    const refreshToken = nonempty(value["refreshToken"]);
-    const accountId = nonempty(value["accountId"]);
+    const accessToken = nonempty(value["accessToken"], USER_STORE_LIMITS.accountToken);
+    const refreshToken = nonempty(value["refreshToken"], USER_STORE_LIMITS.accountToken);
+    const accountId = nonempty(value["accountId"], USER_STORE_LIMITS.accountLabel);
     const expiresAt = value["expiresAt"];
     if (accessToken === undefined ||
         refreshToken === undefined ||
@@ -91,8 +95,8 @@ function normalizeOpenAI(value) {
         !Number.isSafeInteger(expiresAt) ||
         expiresAt <= 0)
         return undefined;
-    const email = nonempty(value["email"]);
-    const plan = nonempty(value["plan"]);
+    const email = nonempty(value["email"], USER_STORE_LIMITS.accountLabel);
+    const plan = nonempty(value["plan"], USER_STORE_LIMITS.accountLabel);
     return {
         accessToken,
         refreshToken,
@@ -102,8 +106,8 @@ function normalizeOpenAI(value) {
         ...(plan === undefined ? {} : { plan }),
     };
 }
-function nonempty(value) {
-    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+function nonempty(value, max) {
+    return typeof value === "string" && value.length <= max && value.trim() !== "" ? value : undefined;
 }
 function record(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/batch.js

@@ -2,7 +2,6 @@
 //
 // It exists so the agent can be scripted and tested. It shares the controller,
 // the tools and the block renderer with the TUI — only the surface differs.
-import * as readline from "node:readline/promises";
 import { stdin, stdout } from "node:process";
 import { runTurn } from "./controller.js";
 import { resolveContextPolicy } from "./context/capacity.js";
@@ -14,24 +13,30 @@ import { renderBatch } from "./batch-view.js";
 import { columns } from "./ui/render.js";
 import { terminalText } from "./ui/terminal-text.js";
 import { recordAuxiliaryUsage, recordRequestInput, recordUsage } from "./usage.js";
+import { assertPromptLength, boundedInputLines } from "./input-boundary.js";
 export async function runBatch(session, environment = {}) {
-    const rl = environment.lines === undefined ? readline.createInterface({ input: stdin }) : undefined;
-    const lines = environment.lines ?? rl;
     const write = environment.write ?? ((text) => stdout.write(text));
     const width = environment.width ?? columns();
+    const signal = environment.signal;
+    const source = environment.lines ?? boundedInputLines(stdin);
+    const lines = abortableLines(source, signal);
     const emit = (block) => {
         for (const line of renderBatch(block, width, session.palette))
             write(`${line}\n`);
     };
     try {
+        throwIfAborted(signal);
         for await (const raw of lines) {
+            throwIfAborted(signal);
+            assertPromptLength(raw.length);
             const line = raw.trim();
             if (line === "")
                 continue;
             if (line.startsWith("/")) {
                 if ((await handleCommand(line, session, {
                     emit,
-                    compact: () => compactSession(session),
+                    signal,
+                    compact: () => compactSession(session, { signal }),
                 })) === "exit")
                     break;
                 continue;
@@ -87,6 +92,7 @@ export async function runBatch(session, environment = {}) {
                     nodeId: nodeId ?? prospectiveNodeId,
                     coveredMessages: context?.messageCount ?? 0,
                     lastInputTokens: Math.max(session.usage.lastInputTokens, request.inputTokens),
+                    estimatedInputTokens: request.inputTokens,
                     force,
                     policy: request.policy,
                 });
@@ -109,12 +115,54 @@ export async function runBatch(session, environment = {}) {
                     commit(checkpoint, settlement);
                 return compacted;
             };
-            await runTurn(history, options(session, policy), turn, undefined, modelHistory);
+            await runTurn(history, options(session, policy), turn, signal, modelHistory);
             turn.flush();
         }
+        throwIfAborted(signal);
     }
     finally {
-        rl?.close();
+        if (environment.lines === undefined)
+            stdin.pause();
+    }
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted === true)
+        throw signal.reason;
+}
+async function* abortableLines(source, signal) {
+    const iterator = source[Symbol.asyncIterator]();
+    let exhausted = false;
+    try {
+        while (true) {
+            throwIfAborted(signal);
+            const next = signal === undefined
+                ? await iterator.next()
+                : await new Promise((resolve, reject) => {
+                    const abort = () => reject(signal.reason);
+                    signal.addEventListener("abort", abort, { once: true });
+                    iterator.next().then((result) => {
+                        signal.removeEventListener("abort", abort);
+                        resolve(result);
+                    }, (error) => {
+                        signal.removeEventListener("abort", abort);
+                        reject(error);
+                    });
+                });
+            if (next.done === true) {
+                exhausted = true;
+                return;
+            }
+            yield next.value;
+        }
+    }
+    finally {
+        if (!exhausted && iterator.return !== undefined) {
+            const closing = iterator.return();
+            if (signal?.aborted === true)
+                void closing.catch(() => { });
+            else
+                await closing;
+        }
     }
 }
 function options(session, contextPolicy) {

package/dist/context/budget.js

@@ -1,5 +1,5 @@
 // Conservative provider-neutral budgeting for one complete model request.
-import { estimateSerializedTokens } from "./estimate.js";
+import { estimateSerializedTokens, estimateSerializedTokensResponsive, } from "./estimate.js";
 import { MIN_REQUEST_OUTPUT_TOKENS } from "./policy.js";
 const ENVELOPE_OVERHEAD_TOKENS = 64;
 const MESSAGE_OVERHEAD_TOKENS = 8;
@@ -16,12 +16,31 @@ export function estimateRequestInputTokens(envelope) {
         envelope.messages.length * MESSAGE_OVERHEAD_TOKENS +
         envelope.tools.length * TOOL_OVERHEAD_TOKENS;
 }
+/** Preserve the request estimate while yielding during large local inputs. */
+export async function estimateRequestInputTokensResponsive(envelope, signal) {
+    const contentTokens = await estimateSerializedTokensResponsive({
+        system: envelope.system,
+        messages: envelope.messages,
+        tools: envelope.tools,
+    }, signal);
+    return contentTokens +
+        ENVELOPE_OVERHEAD_TOKENS +
+        envelope.messages.length * MESSAGE_OVERHEAD_TOKENS +
+        envelope.tools.length * TOOL_OVERHEAD_TOKENS;
+}
 /** Clamp the configured output ceiling so the complete request remains usable. */
 export function budgetRequest(envelope, configuredMaxOutputTokens, policy) {
-    if (!Number.isSafeInteger(configuredMaxOutputTokens) || configuredMaxOutputTokens <= 0) {
-        throw new Error("max output tokens must be a positive safe integer");
-    }
+    requirePositiveInteger(configuredMaxOutputTokens, "max output tokens");
     const inputTokens = estimateRequestInputTokens(envelope);
+    return finishBudget(inputTokens, configuredMaxOutputTokens, policy);
+}
+/** Reuse an exact estimate already computed for the same request envelope. */
+export function budgetRequestFromInputTokens(inputTokens, configuredMaxOutputTokens, policy) {
+    requirePositiveInteger(inputTokens, "request input tokens");
+    requirePositiveInteger(configuredMaxOutputTokens, "max output tokens");
+    return finishBudget(inputTokens, configuredMaxOutputTokens, policy);
+}
+function finishBudget(inputTokens, configuredMaxOutputTokens, policy) {
     const available = policy.requestLimitTokens - inputTokens;
     const minimum = Math.min(configuredMaxOutputTokens, MIN_REQUEST_OUTPUT_TOKENS);
     if (available < minimum) {
@@ -35,3 +54,8 @@ export function budgetRequest(envelope, configuredMaxOutputTokens, policy) {
         limitTokens: policy.requestLimitTokens,
     });
 }
+function requirePositiveInteger(value, label) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new Error(`${label} must be a positive safe integer`);
+    }
+}

package/dist/context/compactor.js

@@ -1,5 +1,5 @@
 // One bounded provider request that condenses an older context prefix.
-import { budgetRequest } from "./budget.js";
+import { budgetRequestFromInputTokens, estimateRequestInputTokensResponsive, } from "./budget.js";
 import { CONTEXT_LIMITS, summaryMessage } from "./projection.js";
 import { planCompaction } from "./policy.js";
 const SUMMARY_SYSTEM = [
@@ -13,17 +13,18 @@ const SUMMARY_SYSTEM = [
 ].join("\n");
 export async function compactContext(options) {
     const policy = options.policy;
-    const plan = planCompaction(options.context, options.turn, options.coveredMessages, options.lastInputTokens, options.force ?? false, policy);
+    const plan = options.precomputedPlan ?? await planCompaction(options.context, options.turn, options.coveredMessages, options.lastInputTokens, options.force ?? false, policy, options.estimatedInputTokens, options.signal);
     if (plan === undefined)
         return undefined;
     options.onBegin?.();
     try {
         const messages = normalized(plan.prefix);
-        const budget = budgetRequest({
+        const inputTokens = await estimateRequestInputTokensResponsive({
             system: SUMMARY_SYSTEM,
             messages,
             tools: [],
-        }, policy.summaryMaxTokens, policy);
+        }, options.signal);
+        const budget = budgetRequestFromInputTokens(inputTokens, policy.summaryMaxTokens, policy);
         const response = await options.provider.send({
             model: options.model,
             system: SUMMARY_SYSTEM,