@giovannijecha/jecode 0.7.3 → 0.8.0

package/README.md

@@ -22,18 +22,21 @@
 
 <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/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.
+> 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).
 
 ## Why Jecode
 
 - **One visible loop.** One controller talks to the model, runs tools, and
-  returns control to you. Independent reads may overlap inside a step; writes
-  and commands stay ordered. There are no delegated agents or hidden model
-  workers.
+  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
@@ -53,10 +56,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 +96,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 +138,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 +159,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
 ```
 
@@ -183,7 +248,8 @@ Useful controls:
 - **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.
+- **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.
@@ -191,9 +257,11 @@ Useful controls:
 - **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, and interrupt hint. Operational
-feedback uses the same replaceable status area instead of adding noise to the
-conversation or its Markdown export.
+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
 
@@ -254,19 +322,23 @@ settings, then built-in defaults.
 | `--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` | `40` |
+| `--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, Dark Steel. `NO_COLOR` is supported for
+Jecode has one current interface theme, Slate. `NO_COLOR` is supported for
 terminals and pipelines that disable colour.
 
 ## Safety model
@@ -347,14 +419,17 @@ 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 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).
 
 ## Community
 
 - Ask questions, share workflows, and explore early ideas in
   [GitHub Discussions](https://github.com/giovannijecha/jecode/discussions).
 - Report reproducible bugs and focused feature requests through
-  [GitHub Issues](https://github.com/giovannijecha/jecode/issues).
+  [GitHub Issues](https://github.com/giovannijecha/jecode/issues). New
+  capabilities are deferred until the 1.0 stabilization cycle is complete.
 - Report security concerns privately through the repository Security tab.
 
 Public pull requests are not accepted at this stage. Code changes remain a

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

@@ -13,7 +13,7 @@ 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;
@@ -126,7 +126,7 @@ function options(session, contextPolicy) {
         maxTokens: session.config.maxTokens,
         contextPolicy,
         effort: session.config.effort,
-        maxSteps: session.config.maxSteps,
+        maxModelRequests: session.config.maxModelRequests,
         toolContext: { root: session.config.root },
     };
 }
@@ -167,5 +167,8 @@ function events(emit, session) {
         onUsage(usage) {
             recordUsage(session.usage, usage);
         },
+        onRequestInput(inputTokens) {
+            recordRequestInput(session.usage, inputTokens);
+        },
     };
 }

package/dist/cli-info.js

@@ -15,7 +15,7 @@ Options:
   --ollama-host <url>    Ollama Cloud, local, or custom endpoint
   --effort <level>       low, medium, high, xhigh, or max
   --max-tokens <number>  output-token ceiling
-  --max-steps <number>   tool-loop ceiling
+  --max-steps <number>   optional per-turn model-request budget
   --compaction-percent <${MIN_COMPACTION_PERCENT}-${MAX_COMPACTION_PERCENT}>
                           context usage that triggers compaction (default: ${DEFAULT_COMPACTION_PERCENT})
   --reduced-motion       use a steady terminal cursor

package/dist/config.js

@@ -27,6 +27,7 @@ export function loadConfig(argv, saved = readSettings()) {
     if (!EFFORTS.includes(effort)) {
         throw new Error(`unknown effort "${effort}" (expected one of: ${EFFORTS.join(", ")})`);
     }
+    const maxModelRequests = optional(flags["max-steps"], process.env.JECODE_MAX_STEPS, undefined);
     return {
         providerId,
         model: pick(flags.model, process.env.JECODE_MODEL, saved.models?.[providerId] ?? ""),
@@ -37,7 +38,9 @@ export function loadConfig(argv, saved = readSettings()) {
         effort,
         // Every request streams, so a large ceiling costs nothing in timeout risk.
         maxTokens: toInt(pick(flags["max-tokens"], process.env.JECODE_MAX_TOKENS, String(saved.maxTokens ?? 64000)), "max-tokens"),
-        maxSteps: toInt(pick(flags["max-steps"], process.env.JECODE_MAX_STEPS, String(saved.maxSteps ?? 40)), "max-steps"),
+        ...(maxModelRequests === undefined
+            ? {}
+            : { maxModelRequests: toInt(maxModelRequests, "max-steps") }),
         compactionPercent: toPercent(pick(flags["compaction-percent"], process.env.JECODE_COMPACTION_PERCENT, String(saved.compactionPercent ?? DEFAULT_COMPACTION_PERCENT))),
         root: path.resolve(pick(flags.root, undefined, process.cwd())),
         autoApprove: flags["auto-approve"] === "true" ||

package/dist/context/policy.js

@@ -42,16 +42,16 @@ export function planCompaction(context, turn, coveredMessages, lastInputTokens,
     };
 }
 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
-        : 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)));
@@ -114,7 +114,14 @@ function validPolicy(policy) {
         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

@@ -24,7 +24,7 @@ export async function requestAssistant(history, current, specs, options, events,
                 onStream: (event) => events.onStream(event),
                 onStatus: (status) => events.onStatus?.(status),
             });
-            return { message, context };
+            return { message, context, inputTokens: budget.inputTokens };
         }
         catch (error) {
             if (recovered)

package/dist/controller.js

@@ -6,7 +6,7 @@
 import { isToolCall } from "./types.js";
 import { findTool, runTool, toolSpecs } from "./tools/index.js";
 import { requestAssistant } from "./controller-request.js";
-export const MAX_TOOL_CALLS_PER_STEP = 32;
+export const MAX_TOOL_CALLS_PER_RESPONSE = 32;
 /** Independent read calls share one bounded execution wave. */
 export const MAX_CONCURRENT_TOOL_CALLS = 4;
 /**
@@ -28,9 +28,25 @@ export async function runTurn(history, options, events, signal, modelHistory = h
         if (projected !== undefined)
             context = clone([...projected]);
     };
-    for (let step = 0; step < options.maxSteps; step++) {
+    const appendSteering = (messages) => {
+        for (const text of messages) {
+            append({ role: "user", content: [{ kind: "text", text }] });
+        }
+        for (const text of messages) {
+            events.onSteering?.(text);
+        }
+        return messages.length > 0;
+    };
+    let requests = 0;
+    while (true) {
         throwIfAborted(signal);
-        events.onStep?.(step + 1, options.maxSteps);
+        if (options.maxModelRequests !== undefined &&
+            requests >= options.maxModelRequests) {
+            const requestLabel = options.maxModelRequests === 1 ? "request" : "requests";
+            throw new Error(`stopped after ${options.maxModelRequests} model ${requestLabel} (--max-steps limit reached)`);
+        }
+        appendSteering(options.steering?.drain() ?? []);
+        requests++;
         // The message is displayed as it streams; what comes back here is the
         // assembled version, which exists to be appended to the history.
         const response = await requestAssistant(history, context, specs, options, events, signal);
@@ -41,14 +57,22 @@ export async function runTurn(history, options, events, signal, modelHistory = h
         if (assistant.content.length === 0) {
             throw new Error(`${options.provider.id} completed without an answer or tool call`);
         }
-        if (calls.length > MAX_TOOL_CALLS_PER_STEP) {
-            throw new Error(`provider returned ${calls.length} tool calls in one step (maximum ${MAX_TOOL_CALLS_PER_STEP})`);
+        if (calls.length > MAX_TOOL_CALLS_PER_RESPONSE) {
+            throw new Error(`provider returned ${calls.length} tool calls in one response (maximum ${MAX_TOOL_CALLS_PER_RESPONSE})`);
         }
         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);
+            const steering = options.steering?.drainOrClose();
+            if (steering !== undefined && appendSteering(steering.messages)) {
+                await checkpoint("checkpointed");
+                continue;
+            }
             await checkpoint("completed");
             return; // the model is done — hand back to the user
         }
@@ -58,8 +82,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);
@@ -67,14 +89,15 @@ export async function runTurn(history, options, events, signal, modelHistory = h
                 for (let offset = 0; offset < batch.length; offset++) {
                     throwIfAborted(signal);
                     const call = batch[offset];
-                    events.onToolProgress?.(start + offset + 1, calls.length);
+                    const current = start + offset + 1;
+                    events.onToolPreparing?.(call, current, calls.length);
                     const preview = await look(call, options, signal);
                     throwIfAborted(signal);
                     announced.add(call.id);
                     events.onToolCall(call, preview);
-                    prepared.push({ call, preview });
+                    prepared.push({ call, current, preview });
                 }
-                const runs = await Promise.all(prepared.map(({ call, preview }) => settle(call, options, events, signal, preview)));
+                const runs = await Promise.all(prepared.map(({ call, current, preview }) => settle(call, current, calls.length, options, events, signal, preview)));
                 for (let offset = 0; offset < runs.length; offset++) {
                     const call = prepared[offset]?.call;
                     const run = runs[offset];
@@ -112,9 +135,9 @@ export async function runTurn(history, options, events, signal, modelHistory = h
             throw error;
         }
         append({ role: "user", content: results });
+        appendSteering(options.steering?.drain() ?? []);
         await checkpoint("checkpointed");
     }
-    throw new Error(`gave up after ${options.maxSteps} steps without finishing (raise --max-steps)`);
 }
 function nextBatch(calls, start, tools) {
     const first = calls[start];
@@ -140,12 +163,12 @@ function assertToolCallIds(calls) {
         if (call.id.trim() === "")
             throw new Error("provider returned a tool call without an id");
         if (seen.has(call.id)) {
-            throw new Error("provider returned duplicate tool call ids in one step");
+            throw new Error("provider returned duplicate tool call ids in one response");
         }
         seen.add(call.id);
     }
 }
-async function settle(call, options, events, signal, preview) {
+async function settle(call, current, total, options, events, signal, preview) {
     const tool = findTool(options.tools, call.name);
     if (tool === undefined) {
         return refuse(call, `no such tool: ${call.name}`, "unknown tool");
@@ -157,6 +180,7 @@ async function settle(call, options, events, signal, preview) {
         return refuse(call, "the user declined this call — ask them how to proceed", "declined");
     }
     throwIfAborted(signal);
+    events.onToolStart?.(call, current, total);
     return runTool(tool, call, {
         ...options.toolContext,
         signal,

package/dist/duration.js

@@ -0,0 +1,8 @@
+// One compact duration grammar shared by terminal and exported tool evidence.
+export function toolDuration(durationMs, live = false) {
+    const bounded = Number.isFinite(durationMs) ? Math.max(0, durationMs) : 0;
+    if (!live && bounded < 1_000)
+        return `${Math.round(bounded)}ms`;
+    const seconds = bounded / 1_000;
+    return `${seconds < 10 ? seconds.toFixed(1) : Math.round(seconds)}s`;
+}

package/dist/oauth-http.js

@@ -2,6 +2,7 @@
 //
 // These requests never redirect, never retry, and never retain an unbounded
 // response. Authorization codes and refresh tokens must not leak into errors.
+import { leadingText } from "./text-boundary.js";
 const AUTH_ORIGIN = "https://auth.openai.com";
 const TIMEOUT_MS = 15_000;
 const MAX_BODY_CHARS = 64_000;
@@ -96,7 +97,7 @@ function errorDetail(value, secrets) {
     let safe = detail.replace(/[\r\n]+/g, " ");
     for (const secret of secrets)
         safe = safe.replaceAll(secret, "[credential redacted]");
-    return ` · ${safe.slice(0, 300)}`;
+    return ` · ${leadingText(safe, 300)}`;
 }
 function bodySecrets(body) {
     const values = body.contentType === "application/x-www-form-urlencoded"

package/dist/openai-account.js

@@ -30,29 +30,27 @@ export async function removeOpenAIAccount(signal) {
     }
     return { removed: true, revokeFailed };
 }
-export async function openAIAuthorization(forceToken, signal, onStatus) {
+export async function openAIAuthorization(rejectedToken, signal, onStatus) {
     const account = openAICodexAccount();
     if (account === undefined)
         throw new Error("ChatGPT account is not connected");
-    const mustRefresh = forceToken !== undefined || expiresSoon(account);
+    const mustRefresh = rejectedToken !== undefined || expiresSoon(account);
     const ready = mustRefresh
-        ? await refreshAccount(forceToken, signal, onStatus)
+        ? await refreshAccount(rejectedToken, signal, onStatus)
         : account;
     return { accessToken: ready.accessToken, accountId: ready.accountId };
 }
-async function refreshAccount(forceToken, signal, onStatus) {
+async function refreshAccount(rejectedToken, signal, onStatus) {
     if (refreshing !== undefined)
         return abortable(refreshing, signal);
     if (signal?.aborted === true)
         throw abortReason(signal);
-    onStatus?.("Refreshing ChatGPT sign-in");
     const task = updateOpenAICodexAccount(async (current) => {
         if (current === undefined)
             throw new Error("ChatGPT account is not connected");
-        if (forceToken !== undefined && current.accessToken !== forceToken)
-            return current;
-        if (forceToken === undefined && !expiresSoon(current))
+        if (!requiresAuthorityRefresh(current, rejectedToken))
             return current;
+        onStatus?.("Refreshing ChatGPT sign-in");
         return refreshOpenAITokens(current);
     }).then((account) => {
         if (account === undefined)
@@ -72,6 +70,12 @@ async function refreshAccount(forceToken, signal, onStatus) {
 function expiresSoon(account) {
     return account.expiresAt - Date.now() <= REFRESH_EARLY_MS;
 }
+function requiresAuthorityRefresh(account, rejectedToken) {
+    // A different fresh token means another process already recovered. An
+    // expiring replacement still needs rotation, while a rejected current token
+    // must be rotated regardless of its advertised expiry.
+    return expiresSoon(account) || account.accessToken === rejectedToken;
+}
 function abortable(promise, signal) {
     if (signal === undefined)
         return promise;

package/dist/openai-oauth-callback.js

@@ -2,6 +2,7 @@
 import { timingSafeEqual } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { createServer } from "node:http";
+import { leadingText } from "./text-boundary.js";
 const CALLBACK_PORTS = [1455, 1457];
 export const OPENAI_CALLBACK_PATH = "/auth/callback";
 export async function openAICallback(state) {
@@ -42,7 +43,7 @@ export async function openAICallback(state) {
         const authError = incoming.searchParams.get("error_description") ?? incoming.searchParams.get("error");
         const authorizationCode = incoming.searchParams.get("code");
         if (authError !== null) {
-            rejectCode(new Error(`ChatGPT sign-in was rejected · ${authError.slice(0, 300)}`));
+            rejectCode(new Error(`ChatGPT sign-in was rejected · ${leadingText(authError, 300)}`));
         }
         else if (authorizationCode === null || authorizationCode === "") {
             rejectCode(new Error("ChatGPT sign-in returned no authorization code"));

package/dist/providers/anthropic-stream.js

@@ -9,6 +9,7 @@ import { addBounded, MAX_TOOL_ARGUMENT_CHARS } from "./stream-limits.js";
 export async function assembleAnthropic(events, onStream) {
     const blocks = new Map();
     const partialJson = new Map();
+    const announcedTools = new Set();
     const sizes = { toolArguments: 0 };
     let stopReason;
     let stopDetails;
@@ -23,6 +24,13 @@ export async function assembleAnthropic(events, onStream) {
             case "content_block_start": {
                 if (typeof event.index === "number" && event.content_block !== undefined) {
                     blocks.set(event.index, { ...event.content_block });
+                    if (event.content_block["type"] === "tool_use" &&
+                        !announcedTools.has(event.index)) {
+                        announcedTools.add(event.index);
+                        const rawName = event.content_block["name"];
+                        const name = typeof rawName === "string" && rawName !== "" ? rawName : undefined;
+                        onStream?.({ kind: "tool", ...(name === undefined ? {} : { name }) });
+                    }
                 }
                 break;
             }