nexrall-code 0.5.47 → 0.5.48

package/dist/index.js

@@ -3156,6 +3156,8 @@ var require_auth = __commonJS({
     exports.clearAuth = clearAuth2;
     exports.isAuthenticated = isAuthenticated3;
     exports.getToken = getToken;
+    exports.getRefreshToken = getRefreshToken;
+    exports.updateTokens = updateTokens;
     var fs9 = __importStar(__require("fs"));
     var path6 = __importStar(__require("path"));
     var os6 = __importStar(__require("os"));
@@ -3205,6 +3207,34 @@ var require_auth = __commonJS({
       const auth = loadAuth();
       return auth?.token ?? null;
     }
+    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;
+    }
+    function updateTokens(token, refreshToken) {
+      let existing = {};
+      try {
+        if (fs9.existsSync(CONFIG_FILE)) {
+          const parsed = JSON.parse(fs9.readFileSync(CONFIG_FILE, "utf-8"));
+          if (typeof parsed === "object" && parsed !== null)
+            existing = parsed;
+        }
+      } catch {
+      }
+      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 } : {}
+      };
+      fs9.writeFileSync(CONFIG_FILE, JSON.stringify(next, null, 2), { mode: 384 });
+    }
   }
 });
 
@@ -9842,6 +9872,7 @@ var require_client = __commonJS({
     exports.chooseFinalContent = chooseFinalContent;
     exports.streamChat = streamChat;
     exports.cancelTurn = cancelTurn;
+    exports.revokeRefreshToken = revokeRefreshToken2;
     exports.getBalance = getBalance3;
     exports.exchangeVscodeCode = exchangeVscodeCode;
     exports.login = login2;
@@ -9892,6 +9923,49 @@ var require_client = __commonJS({
         Authorization: `Bearer ${token}`
       };
     }
+    var _refreshInFlight = null;
+    async function refreshAccessToken() {
+      if (_refreshInFlight)
+        return _refreshInFlight;
+      _refreshInFlight = (async () => {
+        const refreshToken = (0, index_1.getRefreshToken)();
+        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;
+          const data = await res.json();
+          if (!data.token)
+            return false;
+          (0, index_1.updateTokens)(data.token, data.refreshToken);
+          return true;
+        } catch {
+          return false;
+        }
+      })();
+      try {
+        return await _refreshInFlight;
+      } finally {
+        _refreshInFlight = null;
+      }
+    }
+    function isExpiredTokenResponse(status, body) {
+      if (status !== 401 && status !== 403)
+        return false;
+      try {
+        const parsed = JSON.parse(body);
+        if (parsed?.error && typeof parsed.error === "object")
+          return false;
+        return typeof parsed?.error === "string" && /token|auth|expired/i.test(parsed.error);
+      } catch {
+        return false;
+      }
+    }
     var MAX_RETRIES = 5;
     var RETRY_BASE_MS = 1e3;
     var RETRY_MAX_MS = 3e4;
@@ -9974,14 +10048,43 @@ var require_client = __commonJS({
           onEvent({ type: "retry_resolved" });
         }
       };
+      const prepareRestart = async (reason) => {
+        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)
+          return false;
+        if (hadRendered) {
+          onEvent({ type: "stream_restart", reason, discardedChars: renderedChars });
+        }
+        return true;
+      };
+      const bodySaysNotResumable = (body) => {
+        try {
+          return JSON.parse(body)?.notResumable === true;
+        } catch {
+          return false;
+        }
+      };
       async function runAttempt() {
         let response;
         let lastErr;
         let inFlightWaits = 0;
         let errorBodyOverride = null;
         let forbiddenExhausted = false;
+        let refreshedThisAttempt = false;
+        let sessionExpired = false;
         for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
           try {
+            errorBodyOverride = null;
             response = await (0, node_fetch_1.default)(...buildFetchArgs());
             if (response.status === 429 && attempt < MAX_RETRIES && canRetry()) {
               reportRetry("Rate limited by the API \u2014 retrying");
@@ -9994,9 +10097,30 @@ var require_client = __commonJS({
               await sleepWithinBudget(backoffMs(attempt));
               continue;
             }
+            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 \u2014 signing you back in");
+                    attempt--;
+                    continue;
+                  }
+                }
+                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;
+              }
+              errorBodyOverride = bodyText;
+            }
             const FORBIDDEN_RETRY_LIMIT = 2;
             if (response.status === 403) {
-              const bodyText = await response.text().catch(() => "");
+              const bodyText = errorBodyOverride ?? await response.text().catch(() => "");
               let isUpstreamForbidden = false;
               try {
                 const parsed = JSON.parse(bodyText);
@@ -10016,35 +10140,22 @@ var require_client = __commonJS({
               errorBodyOverride = bodyText;
               break;
             }
-            if (response.status === 410 && resuming) {
-              await response.text().catch(() => "");
-              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) {
-                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 \u2014 restarting this turn");
-                await sleepWithinBudget(backoffMs(attempt));
-                continue;
+            if (resuming && response.status >= 400 && response.status < 500) {
+              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) {
+                  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 \u2014 restarting this turn");
+                  await sleepWithinBudget(backoffMs(attempt));
+                  continue;
+                }
+                errorBodyOverride = JSON.stringify({ error: "Could not resume this turn \u2014 send your message again." });
+                break;
               }
-              errorBodyOverride = JSON.stringify({ error: "Could not resume this turn \u2014 send your message again." });
+              errorBodyOverride = body;
               break;
             }
             if (response.status === 409) {
@@ -10096,7 +10207,12 @@ var require_client = __commonJS({
           } catch {
             errMsg = errText || errMsg;
           }
-          throw Object.assign(new Error(errMsg), { status: response.status, balance, ...forbiddenExhausted ? { retryable: true } : {} });
+          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");
@@ -10321,6 +10437,8 @@ var require_client = __commonJS({
                     stream.destroy?.();
                     reject(tagTransient(new Error(message)));
                   } else {
+                    clearInterval(heartbeatWatchdog);
+                    stream.destroy?.();
                     onEvent({ type: "error", message });
                     reject(new Error(message));
                   }
@@ -10381,27 +10499,10 @@ var require_client = __commonJS({
             const e2 = err;
             if (e2.retryable && sAttempt < MAX_RETRIES && canRetry()) {
               if (e2.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 \u2014 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 \u2014 restarting this turn",
-                    discardedChars: renderedChars
-                  });
-                }
                 reportRetry("Could not resume \u2014 restarting this turn");
                 await sleepWithinBudget(backoffMs(sAttempt));
                 continue;
@@ -10445,11 +10546,30 @@ var require_client = __commonJS({
       } catch {
       }
     }
+    async function revokeRefreshToken2() {
+      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 {
+      }
+    }
     async function getBalance3() {
-      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();
+      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}`);
@@ -10470,7 +10590,11 @@ var require_client = __commonJS({
       const data = await response.json();
       if (!data.token)
         throw new Error("No token in exchange response");
-      return { token: data.token, email: data.user?.email ?? "" };
+      return {
+        token: data.token,
+        ...data.refreshToken ? { refreshToken: data.refreshToken } : {},
+        email: data.user?.email ?? ""
+      };
     }
     async function login2(email, password) {
       const response = await (0, node_fetch_1.default)(`${exports.API_BASE}/api/auth/login/email`, {
@@ -10486,7 +10610,11 @@ var require_client = __commonJS({
       if (!data.token) {
         throw new Error("Login response missing token");
       }
-      return { token: data.token, email: data.email ?? email };
+      return {
+        token: data.token,
+        ...data.refreshToken ? { refreshToken: data.refreshToken } : {},
+        email: data.email ?? email
+      };
     }
   }
 });
@@ -12606,13 +12734,7 @@ Resolve the conflict (remove <<<<<<< / ======= / >>>>>>> markers and keep the in
           } catch {
           }
         }
-        fs9.writeFileSync(resolved, content, "utf-8");
-        if (existingMode !== void 0) {
-          try {
-            fs9.chmodSync(resolved, existingMode);
-          } catch {
-          }
-        }
+        atomicWrite(resolved, content, existingMode);
         const bytes = Buffer.byteLength(content, "utf-8");
         const lines = content.split("\n").length;
         if (isNew) {
@@ -13326,14 +13448,52 @@ ${globalCapMatches(output)}` : "";
       }
       return { mode: stat2.mode, content: fs9.readFileSync(resolved, "utf-8") };
     }
-    function atomicWritePreservingMode(resolved, data, mode) {
-      const tmp = resolved + ".nexrall_tmp";
-      fs9.writeFileSync(tmp, data, "utf-8");
+    function atomicWrite(resolved, data, mode) {
+      let target = resolved;
       try {
-        fs9.chmodSync(tmp, mode);
+        if (fs9.lstatSync(resolved).isSymbolicLink())
+          target = fs9.realpathSync(resolved);
       } catch {
       }
-      fs9.renameSync(tmp, resolved);
+      const tmp = `${target}.nexrall_tmp_${process.pid}`;
+      try {
+        fs9.writeFileSync(tmp, data, "utf-8");
+      } catch (err) {
+        const code = err.code;
+        if (code === "EACCES" || code === "EPERM" || code === "EROFS") {
+          fs9.writeFileSync(target, data, "utf-8");
+          if (mode !== void 0) {
+            try {
+              fs9.chmodSync(target, mode);
+            } catch {
+            }
+          }
+          return;
+        }
+        try {
+          fs9.rmSync(tmp, { force: true });
+        } catch {
+        }
+        throw err;
+      }
+      try {
+        if (mode !== void 0) {
+          try {
+            fs9.chmodSync(tmp, mode);
+          } catch {
+          }
+        }
+        fs9.renameSync(tmp, target);
+      } catch (err) {
+        try {
+          fs9.rmSync(tmp, { force: true });
+        } catch {
+        }
+        throw err;
+      }
+    }
+    function atomicWritePreservingMode(resolved, data, mode) {
+      atomicWrite(resolved, data, mode);
     }
     function normalizeLF(s2) {
       return s2.replace(/\r\n/g, "\n");
@@ -14738,6 +14898,10 @@ var require_loop = __commonJS({
     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 = contextWindowFor2;
     exports.compactionThresholds = compactionThresholds2;
     exports.estimateBodyBytes = estimateBodyBytes2;
@@ -14900,6 +15064,29 @@ var require_loop = __commonJS({
           _fileLocks.delete(absPath);
       }
     }
+    var MAX_CONCURRENT_SUBTASKS = (() => {
+      const raw = Number(process.env.NEXRALL_MAX_CONCURRENT_SUBTASKS);
+      return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 4;
+    })();
+    function createLimiter(max) {
+      let active = 0;
+      const queue = [];
+      const release2 = () => {
+        active--;
+        queue.shift()?.();
+      };
+      return async (fn) => {
+        if (active >= max)
+          await new Promise((resolve3) => queue.push(resolve3));
+        active++;
+        try {
+          return await fn();
+        } finally {
+          release2();
+        }
+      };
+    }
+    var _subTaskLimit = createLimiter(MAX_CONCURRENT_SUBTASKS);
     function humanDescription(name, input) {
       switch (name) {
         case "read_file":
@@ -14981,16 +15168,71 @@ var require_loop = __commonJS({
           return `Use tool: ${name}`;
       }
     }
-    var MAX_TASK_DEPTH = 2;
+    var MAX_TASK_DEPTH = 1;
     var _subTaskCounter = 0;
     var SUBTASK_TIMEOUT_MS = Number(process.env.NEXRALL_SUBTASK_TIMEOUT_MS) > 0 ? Number(process.env.NEXRALL_SUBTASK_TIMEOUT_MS) : 10 * 60 * 1e3;
+    var SUBTASK_MAX = 48e3;
+    function sliceSafeEnd(s2, max) {
+      if (s2.length <= max)
+        return s2;
+      let end = max;
+      const code = s2.charCodeAt(end - 1);
+      if (code >= 55296 && code <= 56319)
+        end--;
+      return s2.slice(0, end);
+    }
+    function sliceSafeStart(s2, from) {
+      if (from <= 0)
+        return s2;
+      let start = from;
+      const code = s2.charCodeAt(start);
+      if (code >= 56320 && code <= 57343)
+        start++;
+      return s2.slice(start);
+    }
+    function extractSubTaskText(messages, preferLast = true) {
+      const assistants = messages.filter((m2) => m2.role === "assistant");
+      const textOf = (m2) => (m2?.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();
+    }
+    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}
+
+[\u2026 sub-task output truncated (${text.length} chars) \u2014 kept the beginning and end \u2026]
+
+${tail}`;
+    }
+    function summariseSubTaskProgress(messages) {
+      const toolNames = [];
+      for (const m2 of messages) {
+        if (m2.role !== "assistant" || !Array.isArray(m2.content))
+          continue;
+        for (const b of m2.content) {
+          if (b?.type === "tool_use" && typeof b.name === "string")
+            toolNames.push(b.name);
+        }
+      }
+      if (toolNames.length === 0)
+        return "";
+      const counts = /* @__PURE__ */ 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} \xD7${n}` : name).join(", ");
+      return `Tool calls completed before it was stopped (${toolNames.length} total): ${inventory}.`;
+    }
     async function runSubTask(input, options, agentTypes) {
       const prompt2 = typeof input.prompt === "string" ? input.prompt.trim() : "";
       if (!prompt2)
         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 \u2014 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." };
       }
       const requestedType = typeof input.subagent_type === "string" ? input.subagent_type : "";
       const agent = (0, agentTypes_1.findAgentType)(agentTypes, requestedType);
@@ -15064,22 +15306,36 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
           onThinkingProgress: (tok) => options.onThinkingProgress?.(tok)
         });
         if (subAbort.aborted && !options.abortSignal?.aborted) {
-          return { error: `Sub-task stalled and was stopped after ${Math.round(SUBTASK_TIMEOUT_MS / 6e4)} 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).` };
-        }
-        const lastAssistant = [...result].reverse().find((m2) => m2.role === "assistant");
-        let text = (lastAssistant?.content ?? []).filter((b) => b.type === "text").map((b) => b.text).join("").trim();
-        const SUBTASK_MAX = 48e3;
-        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}
-
-[\u2026 sub-task output truncated (${text.length} chars) \u2014 kept the beginning and end \u2026]
-
-${tail}`;
-        }
+          const mins = Math.round(SUBTASK_TIMEOUT_MS / 6e4);
+          const partial = capSubTaskText(extractSubTaskText(result, false));
+          const progress = summariseSubTaskProgress(result);
+          const sections = [
+            `Sub-task STOPPED after ${mins} minutes without completing \u2014 treat the following as PARTIAL, unverified work, not a finished answer.`,
+            progress,
+            partial ? `Partial output before it was stopped:
+
+${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);
+          return { error: sections.join("\n\n") };
+        }
+        const text = capSubTaskText(extractSubTaskText(result, true));
         return { output: text || "(sub-task completed with no text output)" };
       } catch (err) {
+        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:
+
+${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 {
         clearTimeout(timer);
@@ -15678,7 +15934,7 @@ Continue the work from here.` }] });
             if (!permitted) {
               result = { error: "Permission denied by user" };
             } else if (name === "task") {
-              result = await runSubTask(input, options, agentTypes);
+              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);
               if (pre.block) {
@@ -51904,6 +52160,7 @@ async function logoutCommand() {
     console.log();
     return;
   }
+  await (0, import_code_core.revokeRefreshToken)();
   (0, import_code_core.clearAuth)();
   console.log(source_default.green("  \u2713 Logged out."));
   console.log();
@@ -62537,7 +62794,7 @@ var InkReadlineAdapter = class extends EventEmitter3 {
 };
 
 // src/commands/chat.ts
-var CLI_VERSION = "0.5.47";
+var CLI_VERSION = "0.5.48";
 var MODEL_LABELS = {
   turbo: "Nexrall Turbo",
   pro: "Nexrall Pro",
@@ -62622,28 +62879,83 @@ ${content}`);
   }
   return parts.length > 0 ? parts.join("\n\n---\n\n") : void 0;
 }
+var THINK_TAIL_CHARS = 48;
+function composeStatusLine(opts) {
+  const timer = source_default.dim(` (${opts.elapsedSec}s)`);
+  const hint = opts.hint !== false && !opts.detail && opts.elapsedSec >= 15 ? source_default.dim("  \xB7 still running, no output yet is normal for quiet commands") : "";
+  const detail = opts.detail ? source_default.dim(`  ${opts.detail}`) : "";
+  return `${source_default.cyan(opts.frame)} ${source_default.dim(opts.text)}${timer}${detail}${hint}`;
+}
+function formatProgressTokens(tokens) {
+  if (!Number.isFinite(tokens) || tokens <= 0)
+    return "";
+  return tokens >= 1e3 ? `~${(tokens / 1e3).toFixed(1)}k tokens` : `~${tokens} tokens`;
+}
 var Spinner = class {
   interval = null;
   frames = ["\u25D0", "\u25D3", "\u25D1", "\u25D2"];
   i = 0;
   startedAt = 0;
   baseText = "";
-  start(text) {
+  // Extra live detail appended after the elapsed timer (e.g. "~1.2k tokens").
+  // Kept separate from `baseText` and mutated through setDetail() so a stream of
+  // progress events can refresh it WITHOUT restarting the spinner — calling
+  // start() again would reset `startedAt` and the elapsed counter would sit at 0s
+  // forever, which is precisely the "is it frozen?" signal this class exists to
+  // remove.
+  detail = "";
+  // Whether the reassurance hint applies. Off for phases where slowness is
+  // already explained by the detail text (e.g. a live token counter is itself
+  // proof of life, so "no output yet is normal" would be noise).
+  hintEnabled = true;
+  start(text, opts) {
     this.stop();
     this.baseText = text;
+    this.detail = "";
+    this.hintEnabled = opts?.hint !== false;
     this.startedAt = Date.now();
-    this.interval = setInterval(() => {
-      const elapsedSec = Math.floor((Date.now() - this.startedAt) / 1e3);
-      const timer = source_default.dim(` (${elapsedSec}s)`);
-      const hint = elapsedSec >= 15 ? source_default.dim("  \xB7 still running, no output yet is normal for quiet commands") : "";
-      getInkTerminal()?.setLive(`${source_default.cyan(this.frames[this.i % this.frames.length])} ${source_default.dim(this.baseText)}${timer}${hint}`);
-      this.i++;
-    }, 100);
+    this.render();
+    this.interval = setInterval(() => this.render(), 100);
+  }
+  /**
+   * Replace the trailing detail text in place, keeping the elapsed timer running.
+   *
+   * No-op when the spinner isn't active: progress events can arrive a tick after
+   * something else (a tool row, the first text delta) legitimately stopped it, and
+   * resurrecting the spinner there would fight the printed output for the status line.
+   */
+  setDetail(detail) {
+    if (this.interval === null)
+      return;
+    if (this.detail === detail)
+      return;
+    this.detail = detail;
+    this.render();
+  }
+  /** Swap the label without resetting the elapsed timer (phase change within one turn). */
+  setText(text) {
+    if (this.interval === null)
+      return;
+    if (this.baseText === text)
+      return;
+    this.baseText = text;
+    this.render();
+  }
+  render() {
+    getInkTerminal()?.setLive(composeStatusLine({
+      frame: this.frames[this.i % this.frames.length],
+      text: this.baseText,
+      elapsedSec: Math.floor((Date.now() - this.startedAt) / 1e3),
+      detail: this.detail,
+      hint: this.hintEnabled
+    }));
+    this.i++;
   }
   stop() {
     if (this.interval !== null) {
       clearInterval(this.interval);
       this.interval = null;
+      this.detail = "";
       getInkTerminal()?.setLive("");
     }
   }
@@ -62719,8 +63031,26 @@ async function runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrall
   let toolStartTime = 0;
   let lastToolName = "";
   let thinkingTokens = 0;
+  let liveThinkTail = "";
+  const pushStatus = () => {
+    const parts = [];
+    const tok = formatProgressTokens(thinkingTokens);
+    if (tok)
+      parts.push(tok);
+    if (liveThinkTail)
+      parts.push(liveThinkTail);
+    spinner.setDetail(parts.join("  \xB7 "));
+  };
+  const resumeWorking = (label = "working\u2026") => {
+    if (abortSignal.aborted)
+      return;
+    thinkingTokens = 0;
+    liveThinkTail = "";
+    spinner.start(label, { hint: false });
+  };
   setMode(mode);
   console.log();
+  spinner.start("thinking\u2026", { hint: false });
   const result = await (0, import_code_core3.runAgentLoop)(messages, {
     workDir,
     model: modelAlias,
@@ -62728,10 +63058,26 @@ async function runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrall
     nexrallMd,
     mode,
     effort,
+    // The backend streams a cumulative output-token count (routes/code.js's
+    // sendProgress, throttled to ≤5/s) covering thinking, visible text AND
+    // tool-argument JSON. This used to be stored in a variable and rendered only
+    // at message_complete — i.e. after the turn was already over — so during the
+    // long phase it exists to describe, it showed nothing at all.
     onThinkingProgress: (tokens) => {
       thinkingTokens = tokens;
+      pushStatus();
     },
-    onThinkingDelta: () => {
+    // Live thinking text. Previously a hard no-op with the note "shown on
+    // onThinking" — but onThinking only fires at message_complete, so a long
+    // reasoning phase rendered nothing whatsoever until it had finished. Show a
+    // short rolling tail on the status line so the user can see it actively
+    // reasoning, then let onThinking print the proper summary block at the end.
+    onThinkingDelta: (text) => {
+      if (abortSignal.aborted)
+        return;
+      const flat = text.replace(/\s+/g, " ");
+      liveThinkTail = (liveThinkTail + flat).slice(-THINK_TAIL_CHARS);
+      pushStatus();
     },
     onThinking: (text) => {
       if (abortSignal.aborted)
@@ -62739,6 +63085,8 @@ async function runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrall
       spinner.stop();
       console.log(formatThinking(text, thinkingTokens));
       thinkingTokens = 0;
+      liveThinkTail = "";
+      resumeWorking();
     },
     onText: (text) => {
       if (abortSignal.aborted)
@@ -62757,6 +63105,7 @@ async function runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrall
       mdRender.flush();
       spinner.stop();
       console.log(source_default.dim(`  ${text}`));
+      resumeWorking();
     },
     onToolUse: (name, input) => {
       if (abortSignal.aborted)
@@ -62787,6 +63136,7 @@ async function runTurn(messages, modelAlias, workDir, abortSignal, env3, nexrall
       const durationMs = Date.now() - toolStartTime;
       console.log(formatToolResult(lastToolName, res, durationMs));
       toolStartTime = 0;
+      resumeWorking();
     },
     // Ignore a `partial` report: it belongs to a cut-short attempt that was restarted,
     // and the replacement attempt reports the turn's real totals. Letting it through
@@ -63989,7 +64339,7 @@ function pluginListCommand() {
 
 // src/index.ts
 var program2 = new Command();
-program2.name("nex").description("Nexrall Code \u2014 AI coding assistant (powered by Nexrall)").version("0.5.47");
+program2.name("nex").description("Nexrall Code \u2014 AI coding assistant (powered by Nexrall)").version("0.5.48");
 program2.command("auth").description("Login to your Nexrall account").action(authCommand);
 program2.command("logout").description("Log out of your Nexrall account").action(logoutCommand);
 program2.command("update").description("Update nex to the latest version").option("-c, --check", "Check for updates without installing").option("-y, --yes", "Skip confirmation prompt").action(async (opts) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexrall-code",
-  "version": "0.5.47",
+  "version": "0.5.48",
   "description": "Nexrall Code — AI coding assistant for your terminal (headless agent for scripts, CI and automation)",
   "keywords": [
     "ai",
@@ -41,7 +41,7 @@
     "react": "^19.2.8",
     "readline": "^1.3.0",
     "string-width": "^7.2.0",
-    "@nexrall/code-core": "1.4.22"
+    "@nexrall/code-core": "1.4.23"
   },
   "devDependencies": {
     "@aws-sdk/client-s3": "^3.600.0",