@giovannijecha/jecode 0.7.2 → 0.7.4

package/README.md

@@ -53,10 +53,32 @@
 
 Jecode requires **Node.js 22.18+ on the 22.x line, or Node.js 24+**, and npm.
 
+### Install or update
+
+Install the current stable release. Running the same command again updates an
+existing installation:
+
+```console
+npm install --global @giovannijecha/jecode@latest
+```
+
+Confirm the installed version:
+
 ```console
-npm install --global @giovannijecha/jecode
 jecode --version
+```
+
+### Start Jecode
+
+Open the project you want Jecode to work on:
+
+```console
 cd path/to/your/project
+```
+
+Then start Jecode:
+
+```console
 jecode
 ```
 
@@ -71,33 +93,41 @@ change to improve startup performance.
 Use `jecode --root path/to/project` to select another workspace, or
 `jecode --ephemeral` when the conversation must stay memory-only.
 
-Resume a saved conversation for the current workspace with a searchable picker:
+### Resume a conversation
+
+Open the searchable resume picker for the current workspace:
 
 ```console
 jecode resume
-jecode resume --latest
 ```
 
-Run `jecode --help` for every startup option. Windows, Ubuntu, and macOS are
-covered by the project test matrix.
+Resume the most recently updated conversation directly:
 
-### Prereleases
+```console
+jecode resume --latest
+```
 
-The stable npm package is the supported installation artifact. To try an
-opt-in prerelease:
+List every startup option:
 
 ```console
-npm install --global @giovannijecha/jecode@next
+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.
 
-### Update and uninstall
+### Uninstall
 
 ```console
-npm install --global @giovannijecha/jecode
-jecode --version
 npm uninstall --global @giovannijecha/jecode
 ```
 
@@ -105,12 +135,19 @@ Uninstalling the command preserves `~/.jecode`. Remove that directory only when
 you intentionally want to erase saved settings, credentials, accounts, and
 sessions.
 
-If an older GitHub installation still owns the `jecode` executable, remove the
-legacy unscoped package before installing the scoped package:
+### 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
-npm install --global @giovannijecha/jecode
+```
+
+Then install the current scoped package:
+
+```console
+npm install --global @giovannijecha/jecode@latest
 ```
 
 Do not work around the resulting `EEXIST` error with `--force`.
@@ -119,14 +156,39 @@ Do not work around the resulting `EEXIST` error with `--force`.
 
 WSL uses its own Node.js installation and `PATH`; the Node.js version installed
 on Windows does not apply inside it. Keep user-installed npm commands in the
-Linux user path:
+Linux user path. Set the user-level npm prefix:
 
 ```console
 npm config set prefix "$HOME/.local"
+```
+
+Add it to the current shell's `PATH`:
+
+```console
 export PATH="$HOME/.local/bin:$PATH"
-npm install --global @giovannijecha/jecode
+```
+
+Install or update Jecode:
+
+```console
+npm install --global @giovannijecha/jecode@latest
+```
+
+Refresh the command cache:
+
+```console
 hash -r
+```
+
+Confirm which executable will run:
+
+```console
 command -v jecode
+```
+
+Verify the installed version:
+
+```console
 jecode --version
 ```
 
@@ -253,7 +315,7 @@ settings, then built-in defaults.
 | `--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`; not sent by `openai-codex` |
+| `--max-tokens` | `JECODE_MAX_TOKENS` | `64000` ceiling, clamped to the usable request budget; not sent by `openai-codex` |
 | `--max-steps` | `JECODE_MAX_STEPS` | `40` |
 | `--compaction-percent` | `JECODE_COMPACTION_PERCENT` | `85`; accepts `50` through `95` |
 | `--reduced-motion` | `JECODE_REDUCED_MOTION=1` | Off |
@@ -275,8 +337,8 @@ 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 use atomic
-  replacement.
+  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
@@ -343,10 +405,12 @@ npm run check
 ```
 
 Use `npm run tui:lab` to inspect production TUI components with inert local
-fixtures, and `npm run bench:transcript` for a manual long-session rendering
-probe. Architecture and security boundaries are documented in
+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).
+in [docs/brand.md](docs/brand.md). The maintainer release procedure lives in
+[docs/releasing.md](docs/releasing.md).
 
 ## Community
 

package/dist/atomic.js

@@ -8,20 +8,29 @@ export async function atomicWrite(file, content, options = {}) {
     let handle;
     let identity;
     try {
+        throwIfAborted(options.signal);
         await options.validate?.("before-open");
+        throwIfAborted(options.signal);
         const permissions = options.mode ?? (await existingMode(file));
+        throwIfAborted(options.signal);
         handle = await open(temporary, "wx", permissions);
         identity = fileIdentity(await handle.stat());
+        throwIfAborted(options.signal);
         await options.validate?.("before-write");
+        throwIfAborted(options.signal);
         await assertNamedFile(temporary, identity);
         await handle.writeFile(content, "utf8");
+        throwIfAborted(options.signal);
         if (permissions !== undefined && process.platform !== "win32") {
             await handle.chmod(permissions);
         }
         await handle.sync();
+        throwIfAborted(options.signal);
         identity = fileIdentity(await handle.stat());
         await options.validate?.("before-rename");
+        throwIfAborted(options.signal);
         await assertNamedFile(temporary, identity);
+        throwIfAborted(options.signal);
         await rename(temporary, file);
         const completed = handle;
         handle = undefined;
@@ -38,6 +47,11 @@ export async function atomicWrite(file, content, options = {}) {
         throw error;
     }
 }
+function throwIfAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("interrupted");
+}
 async function assertNamedFile(file, expected) {
     const details = await lstat(file);
     if (details.isSymbolicLink() || !sameFile(expected, fileIdentity(details))) {

package/dist/batch.js

@@ -8,12 +8,12 @@ import { runTurn } from "./controller.js";
 import { resolveContextPolicy } from "./context/capacity.js";
 import { compactContext } from "./context/compactor.js";
 import { compactSession } from "./context/manual.js";
-import { isContextOverflow, shouldResolveContextPolicy } from "./context/policy.js";
+import { isContextOverflow } from "./context/policy.js";
 import { handleCommand } from "./commands.js";
 import { renderBatch } from "./batch-view.js";
 import { columns } from "./ui/render.js";
 import { terminalText } from "./ui/terminal-text.js";
-import { recordAuxiliaryUsage, recordUsage } from "./usage.js";
+import { recordAuxiliaryUsage, recordRequestInput, recordUsage } from "./usage.js";
 export async function runBatch(session, environment = {}) {
     const rl = environment.lines === undefined ? readline.createInterface({ input: stdin }) : undefined;
     const lines = environment.lines ?? rl;
@@ -45,7 +45,13 @@ export async function runBatch(session, environment = {}) {
             const prospectiveNodeId = session.conversation.nodes.length + 1;
             let nodeId;
             let context;
-            let contextPolicy;
+            const policy = () => {
+                return resolveContextPolicy({
+                    provider: session.provider,
+                    model: session.model,
+                    compactionPercent: session.config.compactionPercent,
+                });
+            };
             const user = { role: "user", content: [{ kind: "text", text: line }] };
             history.push(user);
             modelHistory.push(structuredClone(user));
@@ -66,19 +72,12 @@ export async function runBatch(session, environment = {}) {
                 }, settlement);
                 nodeId = session.conversation.activeNodeId;
             };
-            const compact = async (checkpoint, projected, reason, error) => {
-                if (reason === "overflow" && (error === undefined || !isContextOverflow(error))) {
-                    return undefined;
-                }
-                const force = reason === "overflow";
-                if (!shouldResolveContextPolicy(projected, session.usage.lastInputTokens, force)) {
+            const compact = async (checkpoint, projected, request) => {
+                if (request.reason === "overflow" &&
+                    (request.error === undefined || !isContextOverflow(request.error))) {
                     return undefined;
                 }
-                contextPolicy ??= resolveContextPolicy({
-                    provider: session.provider,
-                    model: session.model,
-                    compactionPercent: session.config.compactionPercent,
-                });
+                const force = request.reason === "overflow";
                 const result = await compactContext({
                     provider: session.provider,
                     model: session.model,
@@ -87,9 +86,9 @@ export async function runBatch(session, environment = {}) {
                     turn: checkpoint.slice(before),
                     nodeId: nodeId ?? prospectiveNodeId,
                     coveredMessages: context?.messageCount ?? 0,
-                    lastInputTokens: session.usage.lastInputTokens,
+                    lastInputTokens: Math.max(session.usage.lastInputTokens, request.inputTokens),
                     force,
-                    policy: await contextPolicy,
+                    policy: request.policy,
                 });
                 if (result === undefined)
                     return undefined;
@@ -101,12 +100,16 @@ export async function runBatch(session, environment = {}) {
             turn.onContext = compact;
             turn.onCheckpoint = async (checkpoint, settlement, projected) => {
                 commit(checkpoint, settlement);
-                const compacted = await compact(checkpoint, projected, "budget");
+                const compacted = await compact(checkpoint, projected, {
+                    reason: "budget",
+                    policy: await policy(),
+                    inputTokens: session.usage.lastInputTokens,
+                });
                 if (compacted !== undefined)
                     commit(checkpoint, settlement);
                 return compacted;
             };
-            await runTurn(history, options(session), turn, undefined, modelHistory);
+            await runTurn(history, options(session, policy), turn, undefined, modelHistory);
             turn.flush();
         }
     }
@@ -114,13 +117,14 @@ export async function runBatch(session, environment = {}) {
         rl?.close();
     }
 }
-function options(session) {
+function options(session, contextPolicy) {
     return {
         provider: session.provider,
         tools: session.tools,
         model: session.model,
         system: session.system,
         maxTokens: session.config.maxTokens,
+        contextPolicy,
         effort: session.config.effort,
         maxSteps: session.config.maxSteps,
         toolContext: { root: session.config.root },
@@ -163,5 +167,8 @@ function events(emit, session) {
         onUsage(usage) {
             recordUsage(session.usage, usage);
         },
+        onRequestInput(inputTokens) {
+            recordRequestInput(session.usage, inputTokens);
+        },
     };
 }

package/dist/cli-info.js

@@ -18,7 +18,7 @@ Options:
   --max-steps <number>   tool-loop ceiling
   --compaction-percent <${MIN_COMPACTION_PERCENT}-${MAX_COMPACTION_PERCENT}>
                           context usage that triggers compaction (default: ${DEFAULT_COMPACTION_PERCENT})
-  --reduced-motion       disable animated terminal states
+  --reduced-motion       use a steady terminal cursor
   --auto-approve         allow dangerous tools for this process
   --ephemeral            do not save this conversation
   --latest               resume the newest session without a picker

package/dist/config.js

@@ -69,8 +69,9 @@ function optional(flag, env, fallback) {
 }
 function toInt(value, name) {
     const n = Number(value);
-    if (!Number.isInteger(n) || n <= 0)
-        throw new Error(`--${name} must be a positive integer`);
+    if (!Number.isSafeInteger(n) || n <= 0) {
+        throw new Error(`--${name} must be a positive safe integer`);
+    }
     return n;
 }
 function toPercent(value) {

package/dist/context/budget.js

@@ -0,0 +1,37 @@
+// Conservative provider-neutral budgeting for one complete model request.
+import { estimateSerializedTokens } from "./estimate.js";
+import { MIN_REQUEST_OUTPUT_TOKENS } from "./policy.js";
+const ENVELOPE_OVERHEAD_TOKENS = 64;
+const MESSAGE_OVERHEAD_TOKENS = 8;
+const TOOL_OVERHEAD_TOKENS = 16;
+/** Include system text and tool schemas instead of measuring conversation alone. */
+export function estimateRequestInputTokens(envelope) {
+    const contentTokens = estimateSerializedTokens({
+        system: envelope.system,
+        messages: envelope.messages,
+        tools: envelope.tools,
+    });
+    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");
+    }
+    const inputTokens = estimateRequestInputTokens(envelope);
+    const available = policy.requestLimitTokens - inputTokens;
+    const minimum = Math.min(configuredMaxOutputTokens, MIN_REQUEST_OUTPUT_TOKENS);
+    if (available < minimum) {
+        throw new Error(`request input needs approximately ${inputTokens} tokens, leaving ` +
+            `${Math.max(0, available)} of the ${policy.requestLimitTokens}-token safe request budget; ` +
+            `at least ${minimum} output tokens are required`);
+    }
+    return Object.freeze({
+        inputTokens,
+        maxOutputTokens: Math.min(configuredMaxOutputTokens, available),
+        limitTokens: policy.requestLimitTokens,
+    });
+}

package/dist/context/compactor.js

@@ -1,4 +1,5 @@
 // One bounded provider request that condenses an older context prefix.
+import { budgetRequest } from "./budget.js";
 import { CONTEXT_LIMITS, summaryMessage } from "./projection.js";
 import { planCompaction } from "./policy.js";
 const SUMMARY_SYSTEM = [
@@ -17,12 +18,18 @@ export async function compactContext(options) {
         return undefined;
     options.onBegin?.();
     try {
+        const messages = normalized(plan.prefix);
+        const budget = budgetRequest({
+            system: SUMMARY_SYSTEM,
+            messages,
+            tools: [],
+        }, policy.summaryMaxTokens, policy);
         const response = await options.provider.send({
             model: options.model,
             system: SUMMARY_SYSTEM,
-            messages: normalized(plan.prefix),
+            messages,
             tools: [],
-            maxTokens: policy.summaryMaxTokens,
+            maxTokens: budget.maxOutputTokens,
             effort: options.effort,
             signal: options.signal,
         });

package/dist/context/estimate.js

@@ -0,0 +1,31 @@
+// One provider-neutral estimate shared by compaction and request budgeting.
+import { constants, deflateRawSync } from "node:zlib";
+const BYTES_PER_TOKEN = 3;
+const COMPRESSED_BYTES_PER_TOKEN = 5 / 6;
+export function estimateSerializedTokens(value) {
+    const serialized = Buffer.from(JSON.stringify(value), "utf8");
+    const compressedBytes = deflateRawSync(serialized, {
+        level: constants.Z_BEST_SPEED,
+    }).byteLength;
+    const literalTokens = literalTokenFloor(serialized);
+    // Normal prose and source code retain the established byte floor. Data that
+    // compresses poorly approaches the byte-fallback ceiling used by modern
+    // tokenizers. Non-ASCII bytes and punctuation retain a separate literal
+    // floor, including when repeated input compresses unusually well.
+    return Math.min(serialized.byteLength, Math.max(Math.ceil(serialized.byteLength / BYTES_PER_TOKEN), Math.ceil(compressedBytes / COMPRESSED_BYTES_PER_TOKEN), literalTokens));
+}
+function literalTokenFloor(serialized) {
+    let compactableAscii = 0;
+    let literalBytes = 0;
+    for (const byte of serialized) {
+        if ((byte >= 48 && byte <= 57) ||
+            (byte >= 65 && byte <= 90) ||
+            (byte >= 97 && byte <= 122)) {
+            compactableAscii++;
+        }
+        else {
+            literalBytes++;
+        }
+    }
+    return literalBytes + Math.ceil(compactableAscii / BYTES_PER_TOKEN);
+}

package/dist/context/policy.js

@@ -1,9 +1,11 @@
 // Provider-neutral context pressure and safe compaction boundaries.
+import { estimateSerializedTokens } from "./estimate.js";
 export const DEFAULT_COMPACTION_PERCENT = 85;
 export const MIN_COMPACTION_PERCENT = 50;
 export const MAX_COMPACTION_PERCENT = 95;
-export const CONTEXT_CAPACITY_PROBE_TOKENS = 16_000;
 export const FALLBACK_CONTEXT_WINDOW_TOKENS = 200_000;
+export const REQUEST_ESTIMATE_HEADROOM_PERCENT = 5;
+export const MIN_REQUEST_OUTPUT_TOKENS = 256;
 export function planCompaction(context, turn, coveredMessages, lastInputTokens, force, policy) {
     if (!validPolicy(policy) || coveredMessages < 0 || coveredMessages > turn.length)
         return undefined;
@@ -39,25 +41,25 @@ export function planCompaction(context, turn, coveredMessages, lastInputTokens,
         messageCount: boundary,
     };
 }
-export function shouldResolveContextPolicy(context, lastInputTokens, force = false) {
-    return force || Math.max(estimateTokens(context), lastInputTokens) >= CONTEXT_CAPACITY_PROBE_TOKENS;
-}
 export function policyForContextWindow(context, compactionPercent) {
-    const windowTokens = validWindow(context?.tokens)
-        ? context.tokens
-        : FALLBACK_CONTEXT_WINDOW_TOKENS;
+    const windowTokens = context === undefined
+        ? FALLBACK_CONTEXT_WINDOW_TOKENS
+        : requireWindow(context.tokens);
     const percent = validPercent(compactionPercent)
         ? compactionPercent
         : DEFAULT_COMPACTION_PERCENT;
     const percentageLimit = Math.floor(windowTokens * percent / 100);
-    const providerLimit = validWindow(context?.compactAtTokens)
-        ? context.compactAtTokens
-        : percentageLimit;
-    const triggerTokens = Math.min(percentageLimit, providerLimit, windowTokens);
+    const providerLimit = context?.compactAtTokens === undefined
+        ? windowTokens
+        : requireWindow(context.compactAtTokens);
+    const requestLimitTokens = Math.floor(Math.min(providerLimit, windowTokens) * (100 - REQUEST_ESTIMATE_HEADROOM_PERCENT) / 100);
+    const triggerTokens = Math.min(percentageLimit, requestLimitTokens - MIN_REQUEST_OUTPUT_TOKENS);
     const targetTokens = Math.max(512, Math.min(Math.floor(windowTokens / 4), Math.floor(triggerTokens / 2)));
     const recentTokens = Math.max(256, Math.min(Math.floor(windowTokens / 8), Math.floor(targetTokens / 2)));
     const minimumPrefixTokens = Math.max(256, Math.min(Math.floor(windowTokens / 20), Math.floor(targetTokens / 2)));
     return Object.freeze({
+        windowTokens,
+        requestLimitTokens,
         triggerTokens,
         targetTokens,
         recentTokens,
@@ -66,8 +68,7 @@ export function policyForContextWindow(context, compactionPercent) {
     });
 }
 export function estimateTokens(messages) {
-    const bytes = Buffer.byteLength(JSON.stringify(messages), "utf8");
-    return Math.ceil(bytes / 3) + messages.length * 8;
+    return estimateSerializedTokens(messages) + messages.length * 8;
 }
 export function isContextOverflow(error) {
     const candidate = error;
@@ -108,10 +109,19 @@ function safeBoundary(turn, index) {
 }
 function validPolicy(policy) {
     return Object.values(policy).every((value) => Number.isSafeInteger(value) && value > 0) &&
+        policy.requestLimitTokens <= policy.windowTokens &&
+        policy.triggerTokens <= policy.requestLimitTokens &&
         policy.targetTokens < policy.triggerTokens && policy.recentTokens < policy.triggerTokens;
 }
 function validWindow(value) {
-    return value !== undefined && Number.isSafeInteger(value) && value >= 4_096 && value <= 10_000_000;
+    // Adapters validate raw capacities at 4K before applying their own usable
+    // headroom. The resulting safe capacity can therefore be slightly smaller.
+    return value !== undefined && Number.isSafeInteger(value) && value >= 1_024 && value <= 10_000_000;
+}
+function requireWindow(value) {
+    if (validWindow(value))
+        return value;
+    throw new Error(`provider reported an invalid usable context window: ${value}`);
 }
 function validPercent(value) {
     return Number.isSafeInteger(value) &&

package/dist/controller-request.js

@@ -1,27 +1,37 @@
 // One streamed provider request with a single safe context-overflow recovery.
+import { budgetRequest, estimateRequestInputTokens } from "./context/budget.js";
+import { isContextOverflow } from "./context/policy.js";
 export async function requestAssistant(history, current, specs, options, events, signal) {
-    const prepared = await events.onContext?.(history, current, "budget");
+    let policy = await options.contextPolicy();
+    const prepared = await prepareContext(history, current, specs, options, events, policy, "budget");
     let context = prepared === undefined ? [...current] : clone(prepared);
     let recovered = false;
     for (;;) {
+        const budget = budgetRequest({
+            system: options.system,
+            messages: context,
+            tools: specs,
+        }, options.maxTokens, policy);
         try {
             const message = await options.provider.send({
                 model: options.model,
                 system: options.system,
                 messages: context,
                 tools: specs,
-                maxTokens: options.maxTokens,
+                maxTokens: budget.maxOutputTokens,
                 effort: options.effort,
                 signal,
                 onStream: (event) => events.onStream(event),
                 onStatus: (status) => events.onStatus?.(status),
             });
-            return { message, context };
+            return { message, context, inputTokens: budget.inputTokens };
         }
         catch (error) {
             if (recovered)
                 throw error;
-            const projected = await events.onContext?.(history, context, "overflow", error);
+            if (isContextOverflow(error))
+                policy = await options.contextPolicy();
+            const projected = await prepareContext(history, context, specs, options, events, policy, "overflow", error);
             if (projected === undefined)
                 throw error;
             context = clone(projected);
@@ -29,6 +39,19 @@ export async function requestAssistant(history, current, specs, options, events,
         }
     }
 }
+async function prepareContext(history, context, specs, options, events, policy, reason, error) {
+    const inputTokens = estimateRequestInputTokens({
+        system: options.system,
+        messages: context,
+        tools: specs,
+    });
+    return events.onContext?.(history, context, {
+        reason,
+        policy,
+        inputTokens,
+        ...(error === undefined ? {} : { error }),
+    });
+}
 function clone(messages) {
     return structuredClone([...messages]);
 }

package/dist/controller.js

@@ -17,6 +17,7 @@ export const MAX_CONCURRENT_TOOL_CALLS = 4;
 export async function runTurn(history, options, events, signal, modelHistory = history) {
     const specs = toolSpecs(options.tools);
     let context = modelHistory;
+    throwIfAborted(signal);
     const append = (message) => {
         history.push(message);
         if (context !== history)
@@ -44,10 +45,13 @@ export async function runTurn(history, options, events, signal, modelHistory = h
             throw new Error(`provider returned ${calls.length} tool calls in one step (maximum ${MAX_TOOL_CALLS_PER_STEP})`);
         }
         assertToolCallIds(calls);
+        if (assistant.usage !== undefined)
+            events.onUsage?.(assistant.usage);
+        events.onRequestInput?.(assistant.usage !== undefined && assistant.usage.inputTokens > 0
+            ? assistant.usage.inputTokens
+            : response.inputTokens);
         append(assistant);
         if (calls.length === 0) {
-            if (assistant.usage !== undefined)
-                events.onUsage?.(assistant.usage);
             await checkpoint("completed");
             return; // the model is done — hand back to the user
         }
@@ -57,8 +61,6 @@ export async function runTurn(history, options, events, signal, modelHistory = h
         const results = [];
         const announced = new Set();
         try {
-            if (assistant.usage !== undefined)
-                events.onUsage?.(assistant.usage);
             while (results.length < calls.length) {
                 const start = results.length;
                 const batch = nextBatch(calls, start, options.tools);