@nexrall/code-core 1.4.22 → 1.4.23

package/dist/agent/loop.d.ts

@@ -1,5 +1,41 @@
 import type { Message, AgentLoopOptions, EnvContext } from '../types';
 export declare function resolveMaxIterations(optionValue: number | undefined, settingsRaw: Record<string, unknown>): number;
+/**
+ * Minimal concurrency gate. Hand-rolled rather than pulling in `p-limit` because
+ * the CLI ships as a single esbuild bundle with no node_modules, and this is a
+ * dozen lines.
+ */
+export declare function createLimiter(max: number): <T>(fn: () => Promise<T>) => Promise<T>;
+/**
+ * Reduce a sub-agent's message history to the text its parent should receive.
+ *
+ * Pure + exported so the salvage rules can be tested without running a real
+ * sub-agent (which needs a live model stream and, for the timeout path, ten
+ * minutes of wall clock).
+ *
+ * `preferLast` — the normal completion path — returns the final assistant
+ * message, which is the sub-agent's actual answer.
+ *
+ * `preferLast: false` is the SALVAGE path, used when the sub-agent was cut off.
+ * A stopped sub-agent usually has no closing summary at all (it was killed
+ * mid-tool-round), so the last assistant message is frequently empty or a
+ * fragment. Concatenating what it did produce is far more useful to the parent
+ * model than nothing: it can build on the work instead of redoing it.
+ */
+export declare function extractSubTaskText(messages: Message[], preferLast?: boolean): string;
+/** Apply the parent-context cap to a sub-task's text, keeping head + tail. */
+export declare function capSubTaskText(text: string, max?: number): string;
+/**
+ * Summarise what a cut-short sub-agent actually accomplished, so the parent model
+ * can continue from it rather than starting over.
+ *
+ * This is the whole point of the salvage path. Previously a timed-out sub-agent
+ * returned ONLY an error string: ten minutes of work, dozens of tool calls and
+ * any files it wrote were invisible to the parent, which typically responded by
+ * re-running the same work from scratch — while the tokens for the discarded run
+ * had already been billed in full.
+ */
+export declare function summariseSubTaskProgress(messages: Message[]): string;
 /** The context window (tokens) for a model alias — the same lookup runAgentLoop uses internally. */
 export declare function contextWindowFor(model?: 'turbo' | 'pro' | 'ultra'): number;
 /** Auto-prune / auto-compact thresholds as fractions of the context window — for UI display (e.g. `/context`). */

package/dist/agent/loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"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"}

package/dist/agent/loop.js

@@ -35,6 +35,10 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERIFY_CMD_RE = exports.WRITE_TOOL_NAMES = void 0;
 exports.resolveMaxIterations = resolveMaxIterations;
+exports.createLimiter = createLimiter;
+exports.extractSubTaskText = extractSubTaskText;
+exports.capSubTaskText = capSubTaskText;
+exports.summariseSubTaskProgress = summariseSubTaskProgress;
 exports.contextWindowFor = contextWindowFor;
 exports.compactionThresholds = compactionThresholds;
 exports.estimateBodyBytes = estimateBodyBytes;
@@ -241,6 +245,58 @@ async function withFileLock(absPath, fn) {
             _fileLocks.delete(absPath);
     }
 }
+// ─── Sub-agent fan-out limiter ────────────────────────────────────────────────
+//
+// Tool calls in one turn run via Promise.all with no ceiling. For ordinary tools
+// that is right — they're cheap and mostly I/O — but a `task` call spawns a WHOLE
+// nested agent loop: its own model stream, its own tool executions, its own
+// sub-process spawns. A model that emits ten `task` blocks in one turn therefore
+// starts ten concurrent agents, each billing tokens and competing for the same
+// CPU, file handles and API rate limit. The practical symptoms are the ones users
+// report as "it got slow and then stalled": every sub-agent's stream slows, some
+// trip their own stall watchdog, and one shared rate limit is spread across ten
+// callers.
+//
+// Anthropic hit the same wall and capped Claude Code's concurrent subagents at 20
+// (v2.1.217, July 2026); community guidance settles far lower, around 3-5, because
+// past that the synthesis overhead cancels the parallelism. We default to 4:
+// enough for genuine fan-out (the case sub-agents exist for), low enough that a
+// runaway `task` burst degrades into a queue instead of a thundering herd.
+//
+// This is a QUEUE, not a rejection: every sub-task still runs, just at most N at a
+// time. Failing the excess would be worse than serialising it.
+const MAX_CONCURRENT_SUBTASKS = (() => {
+    const raw = Number(process.env.NEXRALL_MAX_CONCURRENT_SUBTASKS);
+    return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 4;
+})();
+/**
+ * Minimal concurrency gate. Hand-rolled rather than pulling in `p-limit` because
+ * the CLI ships as a single esbuild bundle with no node_modules, and this is a
+ * dozen lines.
+ */
+function createLimiter(max) {
+    let active = 0;
+    const queue = [];
+    const release = () => {
+        active--;
+        queue.shift()?.();
+    };
+    return async (fn) => {
+        if (active >= max)
+            await new Promise((resolve) => queue.push(resolve));
+        active++;
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+        }
+    };
+}
+// Process-wide, deliberately: the limit exists to protect shared resources (CPU,
+// the API rate limit, file handles), and those are shared across every concurrent
+// turn in this process, not just the tool calls of one message.
+const _subTaskLimit = createLimiter(MAX_CONCURRENT_SUBTASKS);
 // ─── Human-readable tool descriptions ────────────────────────────────────────
 function humanDescription(name, input) {
     switch (name) {
@@ -326,7 +382,15 @@ function humanDescription(name, input) {
     }
 }
 // ─── Sub-task runner ──────────────────────────────────────────────────────────
-const MAX_TASK_DEPTH = 2; // main agent (0) can spawn sub-agents (1) — sub-agents cannot spawn further
+// Deepest nesting level allowed to spawn a sub-agent. The main agent runs at
+// depth 0 and the sub-agents it spawns at depth 1.
+//
+// This is 1, not 2. With 2 the guard below (`depth >= MAX_TASK_DEPTH`) let a
+// depth-1 sub-agent spawn depth-2 grandchildren — contradicting both the constant's
+// own comment and the system prompt's promise that "sub-agents cannot spawn further
+// sub-agents", and quietly making the worst-case fan-out quadratic. The value and
+// the documented behaviour now agree.
+const MAX_TASK_DEPTH = 1;
 let _subTaskCounter = 0; // unique per-process id → per-sub-agent todo scope
 // A sub-agent that stalls (hung tool, model provider stuck, infinite tool-call
 // loop bypassing the iteration budget somehow) used to have NO ceiling of its
@@ -338,13 +402,112 @@ let _subTaskCounter = 0; // unique per-process id → per-sub-agent todo scope
 const SUBTASK_TIMEOUT_MS = Number(process.env.NEXRALL_SUBTASK_TIMEOUT_MS) > 0
     ? Number(process.env.NEXRALL_SUBTASK_TIMEOUT_MS)
     : 10 * 60 * 1000; // 10 minutes, matching the general industry norm for a stalled-agent cutoff
+/** Cap on the text a sub-task hands back, so one verbose sub-agent can't blow up
+ *  the PARENT's context in a single tool_result. */
+const SUBTASK_MAX = 48000; // chars (~12k tokens)
+/**
+ * Slice `s` to at most `max` UTF-16 units without splitting a surrogate pair.
+ *
+ * A bare `slice()` can cut between the high and low half of a non-BMP character
+ * (emoji, many CJK extension glyphs), producing a lone surrogate — invalid UTF-16
+ * that the Anthropic API rejects outright with "no low surrogate in string". That
+ * exact failure has already been shipped and fixed once in this codebase; every
+ * new cap on model-facing text has to be surrogate-aware from the start.
+ */
+function sliceSafeEnd(s, max) {
+    if (s.length <= max)
+        return s;
+    let end = max;
+    const code = s.charCodeAt(end - 1);
+    if (code >= 0xd800 && code <= 0xdbff)
+        end--; // trailing high surrogate — drop it
+    return s.slice(0, end);
+}
+/** Mirror of sliceSafeEnd for a tail slice: never START on a low surrogate. */
+function sliceSafeStart(s, from) {
+    if (from <= 0)
+        return s;
+    let start = from;
+    const code = s.charCodeAt(start);
+    if (code >= 0xdc00 && code <= 0xdfff)
+        start++; // leading low surrogate — drop it
+    return s.slice(start);
+}
+/**
+ * Reduce a sub-agent's message history to the text its parent should receive.
+ *
+ * Pure + exported so the salvage rules can be tested without running a real
+ * sub-agent (which needs a live model stream and, for the timeout path, ten
+ * minutes of wall clock).
+ *
+ * `preferLast` — the normal completion path — returns the final assistant
+ * message, which is the sub-agent's actual answer.
+ *
+ * `preferLast: false` is the SALVAGE path, used when the sub-agent was cut off.
+ * A stopped sub-agent usually has no closing summary at all (it was killed
+ * mid-tool-round), so the last assistant message is frequently empty or a
+ * fragment. Concatenating what it did produce is far more useful to the parent
+ * model than nothing: it can build on the work instead of redoing it.
+ */
+function extractSubTaskText(messages, preferLast = true) {
+    const assistants = messages.filter((m) => m.role === 'assistant');
+    const textOf = (m) => (m?.content ?? [])
+        .filter((b) => b.type === 'text' && typeof b.text === 'string')
+        .map((b) => b.text)
+        .join('')
+        .trim();
+    if (preferLast)
+        return textOf(assistants[assistants.length - 1]);
+    return assistants.map(textOf).filter(Boolean).join('\n\n').trim();
+}
+/** Apply the parent-context cap to a sub-task's text, keeping head + tail. */
+function capSubTaskText(text, max = SUBTASK_MAX) {
+    if (text.length <= max)
+        return text;
+    const head = sliceSafeEnd(text, Math.floor(max * 0.6));
+    const tail = sliceSafeStart(text, text.length - Math.floor(max * 0.4));
+    return `${head}\n\n[… sub-task output truncated (${text.length} chars) — kept the beginning and end …]\n\n${tail}`;
+}
+/**
+ * Summarise what a cut-short sub-agent actually accomplished, so the parent model
+ * can continue from it rather than starting over.
+ *
+ * This is the whole point of the salvage path. Previously a timed-out sub-agent
+ * returned ONLY an error string: ten minutes of work, dozens of tool calls and
+ * any files it wrote were invisible to the parent, which typically responded by
+ * re-running the same work from scratch — while the tokens for the discarded run
+ * had already been billed in full.
+ */
+function summariseSubTaskProgress(messages) {
+    const toolNames = [];
+    for (const m of messages) {
+        if (m.role !== 'assistant' || !Array.isArray(m.content))
+            continue;
+        for (const b of m.content) {
+            if (b?.type === 'tool_use' && typeof b.name === 'string')
+                toolNames.push(b.name);
+        }
+    }
+    if (toolNames.length === 0)
+        return '';
+    // Collapse to "name ×N" so a 40-call run reads as a short inventory rather
+    // than forty repeated lines of the same tool name.
+    const counts = new Map();
+    for (const n of toolNames)
+        counts.set(n, (counts.get(n) ?? 0) + 1);
+    const inventory = [...counts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .map(([name, n]) => (n > 1 ? `${name} ×${n}` : name))
+        .join(', ');
+    return `Tool calls completed before it was stopped (${toolNames.length} total): ${inventory}.`;
+}
 async function runSubTask(input, options, agentTypes) {
     const prompt = typeof input.prompt === 'string' ? input.prompt.trim() : '';
     if (!prompt)
         return { error: 'task tool requires a non-empty prompt' };
     const depth = options._depth ?? 0;
     if (depth >= MAX_TASK_DEPTH) {
-        return { error: `Sub-task depth limit (${MAX_TASK_DEPTH}) reached — sub-agents cannot spawn further sub-agents.` };
+        return { error: 'Sub-agents cannot spawn further sub-agents. Do this work directly, or report back so the main agent can delegate it.' };
     }
     // Resolve an optional custom agent type (subagent_type).
     const requestedType = typeof input.subagent_type === 'string' ? input.subagent_type : '';
@@ -423,32 +586,57 @@ async function runSubTask(input, options, agentTypes) {
             onThinkingDelta: (text) => options.onThinkingDelta?.(text),
             onThinkingProgress: (tok) => options.onThinkingProgress?.(tok),
         });
-        // The sub-agent stopped because it hit the stall timeout (not because it
-        // finished or the parent aborted) — report this distinctly so the model
-        // (and the user, via the tool_result) understands WHY it got cut short,
-        // instead of silently receiving whatever partial text happened to exist.
+        // ── Stall timeout: SALVAGE, don't discard ────────────────────────────────
+        //
+        // The sub-agent hit its wall-clock cap (rather than finishing, or the parent
+        // aborting). This used to return ONLY an error string — throwing away
+        // everything the sub-agent had produced in up to ten minutes of work. The
+        // tokens were billed in full either way, and the parent model, told merely
+        // that "it stalled", would routinely re-run the identical work from scratch.
+        //
+        // The timeout still has to be reported unmistakably (the parent must not
+        // mistake a truncated run for a complete answer), but it is reported ALONGSIDE
+        // whatever was actually accomplished, not instead of it. `preferLast: false`
+        // because a killed sub-agent rarely has a closing summary — its useful output
+        // is spread across the assistant turns it did manage to produce.
         if (subAbort.aborted && !options.abortSignal?.aborted) {
-            return { error: `Sub-task stalled and was stopped after ${Math.round(SUBTASK_TIMEOUT_MS / 60000)} minutes with no completion. Consider breaking it into smaller sub-tasks or investigating what it may have been stuck on (a hung command, an unresponsive MCP/tool call, or a very large scope).` };
-        }
-        // Extract final assistant text as the task output
-        const lastAssistant = [...result].reverse().find((m) => m.role === 'assistant');
-        let text = (lastAssistant?.content ?? [])
-            .filter((b) => b.type === 'text')
-            .map((b) => b.text)
-            .join('')
-            .trim();
-        // Cap the sub-agent's returned text so a verbose sub-task (e.g. "list every
-        // usage") can't blow up the PARENT's context in a single tool_result. Keep
-        // the head + tail — the conclusion is usually at the end.
-        const SUBTASK_MAX = 48000; // chars (~12k tokens)
-        if (text.length > SUBTASK_MAX) {
-            const head = text.slice(0, Math.floor(SUBTASK_MAX * 0.6));
-            const tail = text.slice(text.length - Math.floor(SUBTASK_MAX * 0.4));
-            text = `${head}\n\n[… sub-task output truncated (${text.length} chars) — kept the beginning and end …]\n\n${tail}`;
+            const mins = Math.round(SUBTASK_TIMEOUT_MS / 60000);
+            const partial = capSubTaskText(extractSubTaskText(result, false));
+            const progress = summariseSubTaskProgress(result);
+            const sections = [
+                `Sub-task STOPPED after ${mins} minutes without completing — treat the following as PARTIAL, unverified work, not a finished answer.`,
+                progress,
+                partial ? `Partial output before it was stopped:\n\n${partial}` : '',
+                'Do NOT simply re-run the same sub-task: build on what is above, or split the remaining work into smaller, more focused sub-tasks.',
+            ].filter(Boolean);
+            // Returned as `error` (not `output`) on purpose: the loop's ledger counts an
+            // errored call as a non-effect, which is right — nothing here is verified —
+            // and the STALL_LIMIT runaway guard must still see repeated timeouts as
+            // failures so a permanently stuck sub-task can't loop forever.
+            return { error: sections.join('\n\n') };
         }
+        // Normal completion: the final assistant message is the sub-agent's answer.
+        const text = capSubTaskText(extractSubTaskText(result, true));
         return { output: text || '(sub-task completed with no text output)' };
     }
     catch (err) {
+        // Same salvage rule as the timeout path above, for the other way a sub-agent
+        // dies: runAgentLoop throws AgentTurnError when its stream fails, and that
+        // error CARRIES the history completed up to the failure precisely so callers
+        // don't lose it (see types.ts). Discarding it here — as this catch used to —
+        // reproduced the exact waste that class was written to prevent, one level down.
+        const salvaged = (0, types_1.salvageHistory)(err);
+        if (salvaged) {
+            const partial = capSubTaskText(extractSubTaskText(salvaged, false));
+            const progress = summariseSubTaskProgress(salvaged);
+            const sections = [
+                `Sub-task FAILED before completing: ${err.message}`,
+                progress,
+                partial ? `Partial output before the failure:\n\n${partial}` : '',
+                'Treat the above as PARTIAL, unverified work. Build on it rather than re-running the whole sub-task.',
+            ].filter(Boolean);
+            return { error: sections.join('\n\n') };
+        }
         return { error: `Sub-task failed: ${err.message}` };
     }
     finally {
@@ -1515,7 +1703,26 @@ async function runAgentLoop(initialMessages, options) {
                     result = { error: 'Permission denied by user' };
                 }
                 else if (name === 'task') {
-                    result = await runSubTask(input, options, agentTypes);
+                    // Gated so a burst of `task` blocks in one message becomes a QUEUE
+                    // rather than N concurrent agent loops (see MAX_CONCURRENT_SUBTASKS).
+                    //
+                    // The gate wraps the CALL, not the inside of runSubTask, and that
+                    // placement is the whole trick: runSubTask arms its own 10-minute stall
+                    // timeout as its first act, so acquiring the slot inside it would start
+                    // that clock while the sub-task was still sitting in the queue. A
+                    // sub-task queued behind three long-running siblings could then be
+                    // "stopped for stalling" having never executed a single step.
+                    //
+                    // Only TOP-LEVEL fan-out is gated (`depth === 0`) — a deliberate
+                    // deadlock guard, kept even though MAX_TASK_DEPTH currently makes a
+                    // nested spawn impossible anyway. A nested spawn would request a slot
+                    // while its parent still holds one; if every slot were held by a parent
+                    // waiting on a child that can never be scheduled, the run would wedge
+                    // permanently. Keeping the limiter acyclic (a holder never re-enters it)
+                    // means raising MAX_TASK_DEPTH later can't silently reintroduce that.
+                    result = depth === 0
+                        ? await _subTaskLimit(() => runSubTask(input, options, agentTypes))
+                        : await runSubTask(input, options, agentTypes);
                 }
                 else {
                     const pre = runToolHooks(hooks.PreToolUse, 'PreToolUse', name, input, options.workDir);

package/dist/api/client.d.ts

@@ -76,6 +76,18 @@ export declare function streamChat(messages: Message[], options: StreamChatOptio
  * bounds the cost if this request never lands.
  */
 export declare function cancelTurn(turnId: string): Promise<void>;
+/**
+ * Revoke the stored refresh token server-side.
+ *
+ * Deleting the local config alone is NOT a logout once refresh tokens exist: the
+ * token stays valid for its full 60-day life and can keep minting access tokens
+ * for anyone who recovered it (a synced dotfile, a backup, a shared machine).
+ * The backend already exposes /api/auth/logout for exactly this.
+ *
+ * Best-effort and never throws — a failed revoke must not stop the local
+ * credentials from being cleared, which is the part the user can see.
+ */
+export declare function revokeRefreshToken(): Promise<void>;
 export declare function getBalance(): Promise<number>;
 export declare function exchangeVscodeCode(code: string): Promise<AuthConfig>;
 export declare function login(email: string, password: string): Promise<AuthConfig>;

package/dist/api/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAA8B,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAiErH,eAAO,MAAM,QAAQ,QAAmB,CAAC;AAIzC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EAC5D,OAAO,EAAE,CAAC,EAAE,EACZ,UAAU,EAAE,KAAK,CAAC;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GACtD,CAAC,EAAE,CAeL;AAeD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IACnC,oFAAoF;IACpF,UAAU,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IACjG,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6IAA6I;IAC7I,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;;;;OAeG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAiDD,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,CAAC,CAAC,EAAE,QAAQ,KAAK,IAAI,GAC7B,OAAO,CAAC,OAAO,CAAC,CAu7BlB;AAID;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAU9D;AAID,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CAalD;AAID,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAgB1E;AAID,wBAAsB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAkBhF"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAA8B,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAiErH,eAAO,MAAM,QAAQ,QAAmB,CAAC;AAIzC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EAC5D,OAAO,EAAE,CAAC,EAAE,EACZ,UAAU,EAAE,KAAK,CAAC;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GACtD,CAAC,EAAE,CAeL;AAiGD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IACnC,oFAAoF;IACpF,UAAU,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IACjG,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6IAA6I;IAC7I,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;;;;OAeG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAiDD,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,CAAC,CAAC,EAAE,QAAQ,KAAK,IAAI,GAC7B,OAAO,CAAC,OAAO,CAAC,CA6jClB;AAID;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAU9D;AAID;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAYxD;AAID,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CA0BlD;AAID,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA+B1E;AAID,wBAAsB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA0BhF"}

package/dist/api/client.js

@@ -7,6 +7,7 @@ exports.API_BASE = void 0;
 exports.chooseFinalContent = chooseFinalContent;
 exports.streamChat = streamChat;
 exports.cancelTurn = cancelTurn;
+exports.revokeRefreshToken = revokeRefreshToken;
 exports.getBalance = getBalance;
 exports.exchangeVscodeCode = exchangeVscodeCode;
 exports.login = login;
@@ -115,6 +116,91 @@ function authHeaders() {
         Authorization: `Bearer ${token}`,
     };
 }
+// ─── Silent token refresh ─────────────────────────────────────────────────────
+/**
+ * In-flight refresh, shared by every caller that discovers an expired token at the
+ * same moment.
+ *
+ * This is a correctness requirement, not a micro-optimisation. Refresh tokens
+ * ROTATE: presenting one invalidates it and returns a replacement, and presenting
+ * a spent one is treated by the backend as theft (`reuse_detected`) — it revokes
+ * the entire token family and forces a real re-login. A long turn can easily have
+ * several requests in flight (the stream, a cancel, a balance poll), so without
+ * this they would each present the SAME refresh token and all but the first would
+ * look exactly like an attack. De-duplicating means one rotation, one winner,
+ * everyone else awaiting the same promise.
+ */
+let _refreshInFlight = null;
+/**
+ * Exchange the stored refresh token for a fresh access token. Resolves true when
+ * the tokens on disk were updated, false when refreshing isn't possible (no
+ * refresh token stored, or the server rejected it).
+ *
+ * Deliberately never throws: every call site treats `false` as "carry on and let
+ * the original 401/403 surface", which is the correct fallback in all cases.
+ */
+async function refreshAccessToken() {
+    if (_refreshInFlight)
+        return _refreshInFlight;
+    _refreshInFlight = (async () => {
+        const refreshToken = (0, index_1.getRefreshToken)();
+        // No refresh token: a NEXRALL_TOKEN/CI credential, or a config written before
+        // this field existed. Nothing to do — the caller falls back to the auth error.
+        if (!refreshToken)
+            return false;
+        try {
+            const res = await (0, node_fetch_1.default)(`${exports.API_BASE}/api/auth/refresh`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ refreshToken }),
+            });
+            if (!res.ok)
+                return false; // 401 = invalid/expired/reused → a real re-login is needed
+            const data = (await res.json());
+            if (!data.token)
+                return false;
+            (0, index_1.updateTokens)(data.token, data.refreshToken);
+            return true;
+        }
+        catch {
+            // Network failure. Not an auth problem — report failure so the caller's own
+            // retry/backoff machinery handles it as the transport error it is.
+            return false;
+        }
+    })();
+    try {
+        return await _refreshInFlight;
+    }
+    finally {
+        _refreshInFlight = null;
+    }
+}
+/**
+ * Is this response an EXPIRED-CREDENTIAL failure that a refresh could fix?
+ *
+ * The backend's auth middleware answers 401 for a missing token and 403 for one
+ * that is invalid or expired. 403 is ambiguous — Anthropic's upstream
+ * "forbidden" passthrough uses it too — so the body has to disambiguate: the
+ * upstream shape is `{error:{type:'forbidden'}}` (a nested object), while the auth
+ * middleware sends a flat `{error:'Invalid or expired token'}` string. Refreshing
+ * on the upstream shape would be harmless but pointless; getting it backwards and
+ * NOT refreshing on the auth shape is the bug being fixed, so the test suite pins
+ * both directions.
+ */
+function isExpiredTokenResponse(status, body) {
+    if (status !== 401 && status !== 403)
+        return false;
+    try {
+        const parsed = JSON.parse(body);
+        // Nested object → Anthropic's upstream passthrough, not our auth layer.
+        if (parsed?.error && typeof parsed.error === 'object')
+            return false;
+        return typeof parsed?.error === 'string' && /token|auth|expired/i.test(parsed.error);
+    }
+    catch {
+        return false;
+    }
+}
 // ─── Retry helpers ────────────────────────────────────────────────────────────
 const MAX_RETRIES = 5;
 const RETRY_BASE_MS = 1000;
@@ -301,6 +387,71 @@ async function streamChat(messages, options, onEvent) {
             onEvent({ type: 'retry_resolved' });
         }
     };
+    /**
+     * Abandon the current turnId and prepare to restart the turn from scratch.
+     *
+     * Used whenever the server tells us this turn can no longer be followed — the
+     * buffered frame window moved past our cursor (410), the turn is simply gone
+     * (404, e.g. the owning pod was replaced by a deploy), or a mid-stream frame
+     * carried `notResumable`. In all of those cases resuming again with the same
+     * cursor would hit the identical wall, so the only recovery is a clean restart.
+     *
+     * Two things make this more than a state reset, and both are easy to get wrong
+     * — which is why all three call sites funnel through here rather than each
+     * open-coding it:
+     *
+     *  1. The OLD turn must be cancelled and AWAITED first. A 410/404 does not mean
+     *     the turn ended — it is very likely still generating and still holding its
+     *     idempotency claim, so re-POSTing the same turnId would be rejected as
+     *     `turnInFlight` and we would burn the entire retry budget waiting, while
+     *     the orphaned turn kept generating and billing.
+     *  2. Anything already rendered has to be reconciled. A restart re-sends the
+     *     answer from the beginning, so unless the caller can un-render its partial
+     *     output, restarting would duplicate it on screen.
+     *
+     * Returns `false` when the caller cannot roll back its rendered output; the
+     * caller must then surface a terminal error instead of restarting.
+     */
+    const prepareRestart = async (reason) => {
+        await cancelTurn(turnId);
+        turnId = (0, crypto_1.randomUUID)(); // a restart is semantically a NEW turn
+        resuming = false;
+        serverResumable = false;
+        lastEventId = 0;
+        carryText = [];
+        carryToolUse = [];
+        // Snapshot BEFORE resetting: the rollback decision needs to know what the user
+        // can currently see, but the counters must not carry into the restarted turn or
+        // a second restart would report characters this one already discarded.
+        const hadRendered = emittedAnythingAcrossAttempts;
+        const renderedChars = emittedCharsAcrossAttempts;
+        emittedAnythingAcrossAttempts = false;
+        emittedCharsAcrossAttempts = 0;
+        if (hadRendered && !allowRestartAfterRender)
+            return false;
+        if (hadRendered) {
+            onEvent({ type: 'stream_restart', reason, discardedChars: renderedChars });
+        }
+        return true;
+    };
+    /**
+     * Does an error response body carry the backend's explicit `notResumable` flag?
+     *
+     * The resume endpoint sets this on every "give up on this turnId" response
+     * (routes/code.js: the 410 gap case, the 404 no-such-turn case, and the
+     * synthesised mid-stream error frames). Reading the FLAG rather than matching
+     * the status code alone means a new give-up condition on the server is handled
+     * correctly here the day it ships, instead of falling through to the generic
+     * terminal-error path and killing a turn that was perfectly recoverable.
+     */
+    const bodySaysNotResumable = (body) => {
+        try {
+            return JSON.parse(body)?.notResumable === true;
+        }
+        catch {
+            return false;
+        }
+    };
     // One network attempt: connect (with connect-time 429/5xx retry) and consume the stream to
     // completion. Returns the assembled assistant Message, or throws — tagging a transient
     // pre-content failure with { retryable: true } for the outer loop below.
@@ -318,8 +469,19 @@ async function streamChat(messages, options, onEvent) {
         // short in-loop retry budget — the final throw tags `retryable: true` so it still
         // reaches the outer 5-minute stream-retry loop instead of dying as a terminal error.
         let forbiddenExhausted = false;
+        // Whether this attempt has already spent its one silent token refresh. Scoped to
+        // the attempt, not the whole call: if a freshly-minted token is ALSO rejected the
+        // failure isn't expiry, and retrying would pointlessly rotate the refresh token
+        // against a server that keeps refusing.
+        let refreshedThisAttempt = false;
+        // Set when the failure is a dead credential that refreshing could not fix, so the
+        // terminal throw below can tag it `authExpired` — letting the UI show a "sign in
+        // again" prompt instead of a generic error, and keeping it out of the outer
+        // retry loop (a re-login is not something reconnecting can solve).
+        let sessionExpired = false;
         for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
             try {
+                errorBodyOverride = null; // a fresh response — never reuse the previous body
                 response = await (0, node_fetch_1.default)(...buildFetchArgs());
                 if (response.status === 429 && attempt < MAX_RETRIES && canRetry()) {
                     reportRetry('Rate limited by the API — retrying');
@@ -332,6 +494,57 @@ async function streamChat(messages, options, onEvent) {
                     await sleepWithinBudget(backoffMs(attempt));
                     continue;
                 }
+                // ── Expired access token → refresh once, then retry ──────────────────
+                //
+                // The backend issues access tokens with a 2-HOUR TTL and has always
+                // returned a long-lived rotating refresh token alongside them. The web app
+                // refreshes silently; the CLI and extension discarded the refresh token
+                // entirely and stored only the access token — so after exactly two hours,
+                // mid-session, every request started failing with "Invalid or expired
+                // token" and the run simply died with no recovery and no useful guidance.
+                // That is the "it just stops working after a while" report.
+                //
+                // Refreshed at most once per attempt (`refreshedThisAttempt`): if the new
+                // token is ALSO rejected, the problem isn't expiry and looping would just
+                // rotate the refresh token repeatedly against a server that keeps saying no
+                // — every rotation invalidating the previous one.
+                //
+                // A successful refresh retries transparently. This is before any streaming,
+                // so nothing has been rendered and nothing can be duplicated.
+                if (response.status === 401 || response.status === 403) {
+                    const bodyText = await response.text().catch(() => '');
+                    if (isExpiredTokenResponse(response.status, bodyText)) {
+                        if (!refreshedThisAttempt) {
+                            refreshedThisAttempt = true;
+                            if (await refreshAccessToken()) {
+                                reportRetry('Session expired — signing you back in');
+                                attempt--; // a refresh is not a failed attempt; don't spend the budget on it
+                                continue; // buildFetchArgs()/authHeaders() will pick up the new token
+                            }
+                        }
+                        // Either refreshing was impossible (no refresh token stored — a config
+                        // predating this feature, or a NEXRALL_TOKEN credential), it was refused
+                        // (expired/revoked/reused), or the freshly-minted token was rejected too.
+                        // All three genuinely need a human.
+                        //
+                        // Signalled by BREAKING with a rewritten body rather than throwing: a
+                        // throw here lands in this loop's own catch, which cannot tell it from a
+                        // network failure and would retry it — firing a burst of full-context
+                        // POSTs at a credential that will never be accepted. Breaking routes it
+                        // through the terminal `!response.ok` handler below, which is exactly
+                        // what a deterministic auth failure should use.
+                        sessionExpired = true;
+                        errorBodyOverride = JSON.stringify({
+                            // Replaces the backend's bare "Invalid or expired token", which reads
+                            // like a bug rather than something the user can act on.
+                            error: 'Your session has expired. Run `nex login` to sign in again.',
+                        });
+                        break;
+                    }
+                    // Not an expiry — hand the body we already consumed to the handlers below
+                    // (node-fetch bodies are single-use).
+                    errorBodyOverride = bodyText;
+                }
                 // 403 `{"error":{"type":"forbidden","message":"Request not allowed"}}` is
                 // Anthropic's own upstream response shape (reproduced verbatim through the AI
                 // Gateway passthrough — see services/aiGatewayClient.js), not something Nexrall's
@@ -345,7 +558,11 @@ async function streamChat(messages, options, onEvent) {
                 // burning the whole reconnect budget on something that will never succeed.
                 const FORBIDDEN_RETRY_LIMIT = 2;
                 if (response.status === 403) {
-                    const bodyText = await response.text().catch(() => '');
+                    // The expiry check above already consumed the body on this path, and a
+                    // node-fetch body is single-use — calling .text() again yields '' and the
+                    // upstream-forbidden shape would never be recognised, turning a retryable
+                    // blip into an instant terminal failure.
+                    const bodyText = errorBodyOverride ?? await response.text().catch(() => '');
                     let isUpstreamForbidden = false;
                     try {
                         const parsed = JSON.parse(bodyText);
@@ -374,53 +591,49 @@ async function streamChat(messages, options, onEvent) {
                     errorBodyOverride = bodyText;
                     break;
                 }
-                // 410 Gone — a resume was refused because the buffered window no longer contains
-                // our position (we were away too long, or the turn produced a huge amount in the
-                // meantime). Continuity can't be proven, and silently skipping frames would corrupt
-                // the message being rebuilt. So abandon resuming and fall back to restarting the
-                // turn from scratch: correct, just not free.
-                if (response.status === 410 && resuming) {
-                    await response.text().catch(() => '');
-                    // A 410 means the BUFFER WINDOW moved past our cursor — it does NOT mean the turn
-                    // ended. It is almost certainly still generating and still holding its idempotency
-                    // claim, so re-POSTing with the same turnId would be rejected as `turnInFlight`,
-                    // and we would wait out the entire retry budget only to fail — while the orphaned
-                    // turn kept generating and billing.
-                    //
-                    // So: stop the old turn (awaited — the claim must be released BEFORE we re-POST),
-                    // and mint a fresh id, because a restart is semantically a new turn.
-                    await cancelTurn(turnId);
-                    turnId = (0, crypto_1.randomUUID)();
-                    resuming = false;
-                    serverResumable = false;
-                    lastEventId = 0;
-                    carryText = [];
-                    carryToolUse = [];
-                    // Snapshot BEFORE resetting: the rollback decision below needs to know what the
-                    // user can currently see, but the counters must not carry into the restarted turn
-                    // or a second restart would report characters this one already discarded.
-                    const hadRendered = emittedAnythingAcrossAttempts;
-                    const renderedChars = emittedCharsAcrossAttempts;
-                    emittedAnythingAcrossAttempts = false;
-                    emittedCharsAcrossAttempts = 0;
-                    if (hadRendered && !allowRestartAfterRender) {
-                        // Output is already on screen and the caller can't take it back, so a restart
-                        // would duplicate it. Surface the failure instead of corrupting the transcript.
-                        throw new Error('Connection lost and this turn could no longer be resumed. Send your message again.');
-                    }
-                    if (hadRendered) {
-                        onEvent({
-                            type: 'stream_restart',
-                            reason: 'Connection lost too long to resume',
-                            discardedChars: renderedChars,
-                        });
-                    }
-                    if (attempt < MAX_RETRIES && canRetry()) {
-                        reportRetry('Could not resume — restarting this turn');
-                        await sleepWithinBudget(backoffMs(attempt));
-                        continue;
+                // A resume that the server refuses: this turnId can no longer be followed.
+                //
+                //   410 Gone      — the buffered frame window moved past our cursor (we were
+                //                   away too long, or the turn produced a lot meanwhile).
+                //                   Continuity can't be proven and skipping frames would
+                //                   corrupt the message being rebuilt.
+                //   404 Not Found — the turn is gone entirely: nothing buffered AND no live
+                //                   registry record, which is what a deploy/pod replacement
+                //                   looks like from here.
+                //
+                // 404 used to fall straight through to the generic terminal-error handler
+                // below, so a backend rolling restart mid-turn killed the turn outright with
+                // "No such turn to resume." — even though the recovery path for it (mint a
+                // new turnId and restart) was already sitting right here for 410. That was
+                // the "disconnects and never reconnects" case.
+                //
+                // Matched on the backend's explicit `notResumable` flag in the body rather
+                // than on a hardcoded status list, so a new give-up condition on the server
+                // is handled the day it ships. The status check keeps 410 working even if a
+                // proxy strips the body.
+                if (resuming && response.status >= 400 && response.status < 500) {
+                    // May already have been read by the token-expiry check above (401/403);
+                    // node-fetch bodies are single-use, so reuse it rather than reading ''.
+                    const body = errorBodyOverride ?? await response.text().catch(() => '');
+                    if (response.status === 410 || response.status === 404 || bodySaysNotResumable(body)) {
+                        const canRestart = await prepareRestart('Connection lost too long to resume');
+                        if (!canRestart) {
+                            // Output is already on screen and the caller can't take it back, so a restart
+                            // would duplicate it. Surface the failure instead of corrupting the transcript.
+                            throw new Error('Connection lost and this turn could no longer be resumed. Send your message again.');
+                        }
+                        if (attempt < MAX_RETRIES && canRetry()) {
+                            reportRetry('Could not resume — restarting this turn');
+                            await sleepWithinBudget(backoffMs(attempt));
+                            continue;
+                        }
+                        errorBodyOverride = JSON.stringify({ error: 'Could not resume this turn — send your message again.' });
+                        break;
                     }
-                    errorBodyOverride = JSON.stringify({ error: 'Could not resume this turn — send your message again.' });
+                    // A 4xx during resume that is NOT a give-up signal (401/403 auth, 400 bad
+                    // turnId). Deterministic — fall through to the terminal handler, reusing the
+                    // body we already consumed since node-fetch bodies are single-use.
+                    errorBodyOverride = body;
                     break;
                 }
                 // 409 from the backend's turn-idempotency gate. Two distinct meanings, and the
@@ -518,7 +731,16 @@ async function streamChat(messages, options, onEvent) {
             // `retryable: true` on `forbiddenExhausted` hands the transient 403-upstream-forbidden
             // case (see above) to the outer stream-retry loop instead of letting it die as a
             // terminal error the moment the short in-connect-loop budget runs out.
-            throw Object.assign(new Error(errMsg), { status: response.status, balance, ...(forbiddenExhausted ? { retryable: true } : {}) });
+            //
+            // `authExpired` is the opposite signal: the credential is dead and no amount of
+            // reconnecting will help, so it must stay terminal AND be distinguishable, so the
+            // UI can offer a sign-in instead of showing a generic failure.
+            throw Object.assign(new Error(errMsg), {
+                status: response.status,
+                balance,
+                ...(forbiddenExhausted ? { retryable: true } : {}),
+                ...(sessionExpired ? { authExpired: true } : {}),
+            });
         }
         if (!response.body) {
             throw new Error('Response body is null');
@@ -928,6 +1150,15 @@ async function streamChat(messages, options, onEvent) {
                                 reject(tagTransient(new Error(message)));
                             }
                             else {
+                                // Terminal error. The three branches above each stop the watchdog
+                                // and tear the socket down; this one used to do neither, so a
+                                // fatal SSE error left a 5-second interval running and the
+                                // response body open for the lifetime of the process. The
+                                // rejection settles the promise either way, which is exactly why
+                                // the leak was invisible — nothing downstream ever noticed, it
+                                // just accumulated one timer per failed turn across a long session.
+                                clearInterval(heartbeatWatchdog);
+                                stream.destroy?.();
                                 onEvent({ type: 'error', message });
                                 reject(new Error(message));
                             }
@@ -1011,32 +1242,18 @@ async function streamChat(messages, options, onEvent) {
                 if (e.retryable && sAttempt < MAX_RETRIES && canRetry()) {
                     // The backend explicitly said this turnId's buffer is unrecoverable (gap in the
                     // Redis frame stream, or the owning pod is gone — see the `notResumable` case in
-                    // client.ts's SSE parser). Resuming with the same `lastEventId` would just hit
-                    // the same wall again, so — exactly like the inline 410-while-resuming handling
-                    // above — release the old claim, mint a fresh turnId, and restart clean instead
-                    // of falling into the "prefer resuming" branch below.
+                    // the SSE parser above). Resuming with the same `lastEventId` would just hit the
+                    // same wall again, so release the old claim, mint a fresh turnId and restart
+                    // clean instead of falling into the "prefer resuming" branch below.
+                    //
+                    // Shares prepareRestart() with the HTTP-status path in runAttempt: the two used
+                    // to be independent copies of the same fifteen lines, and the cancel-then-remint
+                    // ordering they encode is exactly the kind of thing that silently drifts apart.
                     if (e.forceRestart) {
-                        await cancelTurn(turnId);
-                        turnId = (0, crypto_1.randomUUID)();
-                        resuming = false;
-                        serverResumable = false;
-                        lastEventId = 0;
-                        carryText = [];
-                        carryToolUse = [];
-                        const hadRendered = emittedAnythingAcrossAttempts;
-                        const renderedChars = emittedCharsAcrossAttempts;
-                        emittedAnythingAcrossAttempts = false;
-                        emittedCharsAcrossAttempts = 0;
-                        if (hadRendered && !allowRestartAfterRender) {
+                        const canRestart = await prepareRestart(err.message || 'Could not resume — restarting this turn');
+                        if (!canRestart) {
                             throw new Error('Connection lost and this turn could no longer be resumed. Send your message again.');
                         }
-                        if (hadRendered) {
-                            onEvent({
-                                type: 'stream_restart',
-                                reason: err.message || 'Could not resume — restarting this turn',
-                                discardedChars: renderedChars,
-                            });
-                        }
                         reportRetry('Could not resume — restarting this turn');
                         await sleepWithinBudget(backoffMs(sAttempt));
                         continue;
@@ -1116,12 +1333,50 @@ async function cancelTurn(turnId) {
         // Ignored deliberately — see above.
     }
 }
+// ─── Logout ───────────────────────────────────────────────────────────────────
+/**
+ * Revoke the stored refresh token server-side.
+ *
+ * Deleting the local config alone is NOT a logout once refresh tokens exist: the
+ * token stays valid for its full 60-day life and can keep minting access tokens
+ * for anyone who recovered it (a synced dotfile, a backup, a shared machine).
+ * The backend already exposes /api/auth/logout for exactly this.
+ *
+ * Best-effort and never throws — a failed revoke must not stop the local
+ * credentials from being cleared, which is the part the user can see.
+ */
+async function revokeRefreshToken() {
+    const refreshToken = (0, index_1.getRefreshToken)();
+    if (!refreshToken)
+        return;
+    try {
+        await (0, node_fetch_1.default)(`${exports.API_BASE}/api/auth/logout`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ refreshToken }),
+        });
+    }
+    catch {
+        // Offline logout: the local credentials still get cleared by the caller.
+    }
+}
 // ─── Get Balance ──────────────────────────────────────────────────────────────
 async function getBalance() {
-    const response = await (0, node_fetch_1.default)(`${exports.API_BASE}/api/code/balance`, {
-        method: 'GET',
-        headers: authHeaders(),
-    });
+    const fetchOnce = () => (0, node_fetch_1.default)(`${exports.API_BASE}/api/code/balance`, { method: 'GET', headers: authHeaders() });
+    let response = await fetchOnce();
+    // Same silent refresh as the chat path. This endpoint is polled on session start
+    // and after turns, so on an expired token it is frequently the FIRST thing the
+    // user sees fail — and a startup that reports "API error 403" while the chat
+    // path quietly recovers is just confusing.
+    if (response.status === 401 || response.status === 403) {
+        const body = await response.text().catch(() => '');
+        if (isExpiredTokenResponse(response.status, body) && await refreshAccessToken()) {
+            response = await fetchOnce();
+        }
+        else {
+            throw new Error(`API error ${response.status}: ${body}`);
+        }
+    }
     if (!response.ok) {
         const errText = await response.text();
         throw new Error(`API error ${response.status}: ${errText}`);
@@ -1143,7 +1398,18 @@ async function exchangeVscodeCode(code) {
     const data = (await response.json());
     if (!data.token)
         throw new Error('No token in exchange response');
-    return { token: data.token, email: data.user?.email ?? '' };
+    // `refreshToken` is forwarded when present but is NOT expected today: unlike the
+    // email-login path, /vscode-exchange mints a long-lived (30-day) token directly
+    // rather than going through mintSession's short-access-token + refresh pair. So
+    // the extension is not exposed to the 2-hour expiry that broke CLI sessions —
+    // it just expires much later, with no silent renewal. Reading the field now means
+    // that if the backend is ever switched to mintSession for consistency, the
+    // extension starts refreshing silently instead of breaking at the 2-hour mark.
+    return {
+        token: data.token,
+        ...(data.refreshToken ? { refreshToken: data.refreshToken } : {}),
+        email: data.user?.email ?? '',
+    };
 }
 // ─── Login ────────────────────────────────────────────────────────────────────
 async function login(email, password) {
@@ -1160,6 +1426,14 @@ async function login(email, password) {
     if (!data.token) {
         throw new Error('Login response missing token');
     }
-    return { token: data.token, email: data.email ?? email };
+    // KEEP THE REFRESH TOKEN. The backend has returned one on this path all along
+    // (routes/auth.js mintSession) and pairs it with an access token that expires in
+    // TWO HOURS. Discarding it here is what made a long working session die mid-run
+    // with "Invalid or expired token" and no way back except a manual `nex login`.
+    return {
+        token: data.token,
+        ...(data.refreshToken ? { refreshToken: data.refreshToken } : {}),
+        email: data.email ?? email,
+    };
 }
 //# sourceMappingURL=client.js.map

package/dist/auth/index.d.ts

@@ -4,4 +4,25 @@ export declare function loadAuth(): AuthConfig | null;
 export declare function clearAuth(): void;
 export declare function isAuthenticated(): boolean;
 export declare function getToken(): string | null;
+/**
+ * The stored refresh token, or null when there isn't one to use.
+ *
+ * Deliberately returns null for a token supplied via NEXRALL_TOKEN: that path is
+ * for CI/headless, where the caller owns the credential's lifecycle and there is
+ * no refresh token to pair with it. Silently reading a refresh token out of the
+ * config file while the access token came from the environment would also mix two
+ * different identities if they disagree.
+ */
+export declare function getRefreshToken(): string | null;
+/**
+ * Replace the stored token pair after a successful refresh, preserving any other
+ * fields already in the config (notably `email`, which the refresh response does
+ * not echo back and which the UI shows).
+ *
+ * Refresh tokens ROTATE: the backend invalidates the presented one and returns a
+ * replacement, and reusing a spent token is treated as theft (`reuse_detected`)
+ * and revokes the family. So this must persist BOTH halves, and must not be
+ * skipped just because the access token is what the caller needed.
+ */
+export declare function updateTokens(token: string, refreshToken?: string): void;
 //# sourceMappingURL=index.d.ts.map

package/dist/auth/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auth/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAiB3C,wBAAgB,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAGjD;AAED,wBAAgB,QAAQ,IAAI,UAAU,GAAG,IAAI,CAwB5C;AAED,wBAAgB,SAAS,IAAI,IAAI,CAQhC;AAED,wBAAgB,eAAe,IAAI,OAAO,CAGzC;AAED,wBAAgB,QAAQ,IAAI,MAAM,GAAG,IAAI,CAGxC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auth/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAiB3C,wBAAgB,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAGjD;AAED,wBAAgB,QAAQ,IAAI,UAAU,GAAG,IAAI,CAwB5C;AAED,wBAAgB,SAAS,IAAI,IAAI,CAQhC;AAED,wBAAgB,eAAe,IAAI,OAAO,CAGzC;AAED,wBAAgB,QAAQ,IAAI,MAAM,GAAG,IAAI,CAGxC;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,IAAI,MAAM,GAAG,IAAI,CAM/C;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAsBvE"}

package/dist/auth/index.js

@@ -38,6 +38,8 @@ exports.loadAuth = loadAuth;
 exports.clearAuth = clearAuth;
 exports.isAuthenticated = isAuthenticated;
 exports.getToken = getToken;
+exports.getRefreshToken = getRefreshToken;
+exports.updateTokens = updateTokens;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
@@ -97,4 +99,55 @@ function getToken() {
     const auth = loadAuth();
     return auth?.token ?? null;
 }
+/**
+ * The stored refresh token, or null when there isn't one to use.
+ *
+ * Deliberately returns null for a token supplied via NEXRALL_TOKEN: that path is
+ * for CI/headless, where the caller owns the credential's lifecycle and there is
+ * no refresh token to pair with it. Silently reading a refresh token out of the
+ * config file while the access token came from the environment would also mix two
+ * different identities if they disagree.
+ */
+function getRefreshToken() {
+    const envToken = process.env.NEXRALL_TOKEN;
+    if (envToken && envToken.trim().length > 0)
+        return null;
+    const auth = loadAuth();
+    const rt = auth?.refreshToken;
+    return typeof rt === 'string' && rt.length > 0 ? rt : null;
+}
+/**
+ * Replace the stored token pair after a successful refresh, preserving any other
+ * fields already in the config (notably `email`, which the refresh response does
+ * not echo back and which the UI shows).
+ *
+ * Refresh tokens ROTATE: the backend invalidates the presented one and returns a
+ * replacement, and reusing a spent token is treated as theft (`reuse_detected`)
+ * and revokes the family. So this must persist BOTH halves, and must not be
+ * skipped just because the access token is what the caller needed.
+ */
+function updateTokens(token, refreshToken) {
+    // Read the file directly rather than via loadAuth(): under NEXRALL_TOKEN,
+    // loadAuth short-circuits to the env value and would let a refresh overwrite the
+    // on-disk config with a synthetic single-field object, destroying the user's
+    // real stored credentials.
+    let existing = {};
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            const parsed = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+            if (typeof parsed === 'object' && parsed !== null)
+                existing = parsed;
+        }
+    }
+    catch { /* corrupt or unreadable — start clean rather than refuse to save */ }
+    ensureConfigDir();
+    const next = {
+        ...existing,
+        token,
+        // Keep the previous refresh token if the server didn't send a new one, rather
+        // than deleting the only means of refreshing again.
+        ...(refreshToken ? { refreshToken } : {}),
+    };
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(next, null, 2), { mode: 0o600 });
+}
 //# sourceMappingURL=index.js.map

package/dist/tools/executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/tools/executor.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAyB,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AA6nEtE,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,WAAW,CAAC,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,EAClC,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GACjC,OAAO,CAAC,UAAU,CAAC,CAoBrB"}
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/tools/executor.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAyB,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AA4sEtE,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,WAAW,CAAC,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,EAClC,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GACjC,OAAO,CAAC,UAAU,CAAC,CAoBrB"}

package/dist/tools/executor.js

@@ -405,13 +405,12 @@ async function writeFile(input, workDir) {
             }
             catch { /* ignore */ }
         }
-        fs.writeFileSync(resolved, content, 'utf-8');
-        if (existingMode !== undefined) {
-            try {
-                fs.chmodSync(resolved, existingMode);
-            }
-            catch { /* non-fatal */ }
-        }
+        // Atomic (temp + rename), matching edit_file/multi_edit. A plain
+        // writeFileSync on the target truncates it first and then streams the
+        // content back, so an interrupt partway through a large write left a
+        // TRUNCATED source file and reported nothing — the worst outcome for the
+        // very tool most likely to be handed a huge payload.
+        atomicWrite(resolved, content, existingMode);
         const bytes = Buffer.byteLength(content, 'utf-8');
         const lines = content.split('\n').length;
         if (isNew) {
@@ -1272,15 +1271,102 @@ function preflightEdit(resolved) {
     }
     return { mode: stat.mode, content: fs.readFileSync(resolved, 'utf-8') };
 }
-/** Atomic write that preserves the original file's permission bits (mode). */
-function atomicWritePreservingMode(resolved, data, mode) {
-    const tmp = resolved + '.nexrall_tmp';
-    fs.writeFileSync(tmp, data, 'utf-8');
+/**
+ * Write `data` to `resolved` atomically: build it in a sibling temp file, then
+ * rename over the target. rename(2) is atomic within a filesystem, so a reader —
+ * or a crash — sees either the entire old file or the entire new one, never a
+ * half-written truncation.
+ *
+ * This matters most for exactly the case it used NOT to cover: a large
+ * `write_file`. `fs.writeFileSync` on the target truncates it to zero and then
+ * streams the content back in, so a Ctrl+C, an OOM or a machine losing power
+ * partway through leaves a TRUNCATED source file with no error reported
+ * anywhere — the silent-corruption failure mode this whole module tries to avoid.
+ *
+ * The temp name carries the pid: `withFileLock` in agent/loop.ts serialises
+ * writes to one path within a process, but nothing coordinates two `nex`
+ * processes (or a CLI and the VS Code extension) pointed at the same repo, and
+ * a shared fixed suffix would let them clobber each other's staging file and
+ * commit a mix of both payloads.
+ *
+ * `mode` is optional: a brand-new file has no prior permission bits to keep, and
+ * should get the umask default that writeFileSync would have produced.
+ */
+function atomicWrite(resolved, data, mode) {
+    // Follow a symlink to its real target before staging.
+    //
+    // rename(2) replaces the NAME, so renaming onto a symlink would delete the link
+    // and leave a regular file in its place — silently breaking the indirection the
+    // user set up (a dotfile linked into a repo, a linked config). Plain
+    // writeFileSync followed the link and wrote through it, and that behaviour must
+    // be preserved. Resolving to the real path also keeps the temp file on the same
+    // filesystem as the actual target, which is what makes the rename atomic (and
+    // not an EXDEV failure).
+    let target = resolved;
+    try {
+        if (fs.lstatSync(resolved).isSymbolicLink())
+            target = fs.realpathSync(resolved);
+    }
+    catch {
+        // Doesn't exist yet (the common create case) or is unreadable — write to the
+        // path as given, exactly as before.
+    }
+    const tmp = `${target}.nexrall_tmp_${process.pid}`;
+    // ── Stage ────────────────────────────────────────────────────────────────
+    // Creating the temp file needs WRITE permission on the containing directory,
+    // which a direct write to an existing file does not. That difference is a real
+    // (if uncommon) compatibility break: a writable file inside a read-only
+    // directory used to be editable and would suddenly stop being. Atomicity is a
+    // safety improvement, so it must not take away a capability the user had —
+    // when staging is impossible for that structural reason, fall back to the
+    // previous direct write rather than failing the tool call.
+    try {
+        fs.writeFileSync(tmp, data, 'utf-8');
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'EACCES' || code === 'EPERM' || code === 'EROFS') {
+            fs.writeFileSync(target, data, 'utf-8');
+            if (mode !== undefined) {
+                try {
+                    fs.chmodSync(target, mode);
+                }
+                catch { /* non-fatal */ }
+            }
+            return;
+        }
+        // ENOSPC, EDQUOT, EISDIR, … — genuine failures. Nothing was staged, so the
+        // original file is untouched; surface it.
+        try {
+            fs.rmSync(tmp, { force: true });
+        }
+        catch { /* best effort */ }
+        throw err;
+    }
+    // ── Commit ───────────────────────────────────────────────────────────────
     try {
-        fs.chmodSync(tmp, mode);
+        if (mode !== undefined) {
+            try {
+                fs.chmodSync(tmp, mode);
+            }
+            catch { /* non-fatal — keep going */ }
+        }
+        fs.renameSync(tmp, target);
+    }
+    catch (err) {
+        // Never leave staging debris next to the user's source on a failed commit
+        // (a cross-device target, a permissions change mid-write). The original file
+        // is untouched, which is the entire point of staging.
+        try {
+            fs.rmSync(tmp, { force: true });
+        }
+        catch { /* best effort */ }
+        throw err;
     }
-    catch { /* non-fatal — keep going */ }
-    fs.renameSync(tmp, resolved);
+}
+/** Atomic write that preserves the original file's permission bits (mode). */
+function atomicWritePreservingMode(resolved, data, mode) {
+    atomicWrite(resolved, data, mode);
 }
 // Normalize CRLF → LF so Windows files match LF old_strings.
 function normalizeLF(s) {

package/dist/types.d.ts

@@ -186,7 +186,23 @@ export interface ToolResult {
     exitCode?: number;
 }
 export interface AuthConfig {
+    /** Short-lived access token (the backend issues these with a 2-hour TTL). */
     token: string;
+    /**
+     * Long-lived rotating refresh token, used to mint a new access token without a
+     * manual re-login.
+     *
+     * The backend has issued one on every login path for a long time and exposes
+     * POST /api/auth/refresh to exchange it — the web app uses both. The CLI and
+     * extension simply discarded it and stored the access token alone, so after
+     * exactly two hours every request began failing with "Invalid or expired
+     * token", mid-session, with no recovery: a long working session would just die.
+     *
+     * Optional because it is genuinely absent in two legitimate cases: a token
+     * supplied via NEXRALL_TOKEN (CI/headless, no refresh flow), and a config file
+     * written by a version that predates this field.
+     */
+    refreshToken?: string;
     email?: string;
 }
 export interface PermissionRequest {

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexrall/code-core",
-  "version": "1.4.22",
+  "version": "1.4.23",
   "description": "Core agent loop, tools, and extension primitives for Nexrall Code — embed an AI coding agent in any Node.js application.",
   "license": "MIT",
   "author": "Nexrall <support@nexrall.com> (https://nexrall.com)",