nexrall-code 0.5.2 → 0.5.18

package/dist/index.js

@@ -3070,6 +3070,27 @@ var require_types = __commonJS({
   "../core/dist/types.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.AgentTurnError = void 0;
+    exports2.isAgentTurnError = isAgentTurnError;
+    exports2.salvageHistory = salvageHistory2;
+    var AgentTurnError = class extends Error {
+      constructor(message, messages, progressCount, cause) {
+        super(message);
+        this.name = "AgentTurnError";
+        this.messages = messages;
+        this.progressCount = Math.max(0, progressCount);
+        this.cause = cause;
+      }
+    };
+    exports2.AgentTurnError = AgentTurnError;
+    function isAgentTurnError(err) {
+      return err instanceof AgentTurnError;
+    }
+    function salvageHistory2(err) {
+      if (!isAgentTurnError(err))
+        return null;
+      return err.progressCount > 0 ? err.messages : null;
+    }
   }
 });
 
@@ -9810,14 +9831,49 @@ var require_client = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.API_BASE = void 0;
+    exports2.chooseFinalContent = chooseFinalContent;
     exports2.streamChat = streamChat;
+    exports2.cancelTurn = cancelTurn;
     exports2.getBalance = getBalance3;
     exports2.exchangeVscodeCode = exchangeVscodeCode;
     exports2.login = login2;
     var eventsource_parser_1 = require_dist();
     var node_fetch_1 = __importDefault((init_src(), __toCommonJS(src_exports)));
+    var crypto_1 = require("crypto");
     var index_1 = require_auth();
-    exports2.API_BASE = "https://api.nexrall.com";
+    var DEFAULT_API_BASE = "https://api.nexrall.com";
+    function resolveApiBase() {
+      const raw = process.env.NEXRALL_API_BASE?.trim();
+      if (!raw)
+        return DEFAULT_API_BASE;
+      const isLoopback = /^http:\/\/(127\.0\.0\.1|\[::1\]|localhost)(:\d+)?(\/|$)/i.test(raw);
+      if (isLoopback) {
+        console.error(`\u26A0\uFE0F  Nexrall API override in effect (loopback): ${raw.replace(/\/+$/, "")}`);
+        return raw.replace(/\/+$/, "");
+      }
+      if (process.env.NEXRALL_ALLOW_API_OVERRIDE !== "1") {
+        console.error(`\u26A0\uFE0F  Ignoring NEXRALL_API_BASE="${raw}": redirecting to a remote host also requires NEXRALL_ALLOW_API_OVERRIDE=1, because this variable receives your auth token and source code. Falling back to ${DEFAULT_API_BASE}.`);
+        return DEFAULT_API_BASE;
+      }
+      if (!/^https:\/\//i.test(raw)) {
+        console.error(`\u26A0\uFE0F  Ignoring NEXRALL_API_BASE="${raw}": a remote override must be https:// so your token is never sent in plaintext. Falling back to ${DEFAULT_API_BASE}.`);
+        return DEFAULT_API_BASE;
+      }
+      const base = raw.replace(/\/+$/, "");
+      console.error(`\u26A0\uFE0F  Nexrall API override in effect: ${base}`);
+      return base;
+    }
+    exports2.API_BASE = resolveApiBase();
+    function chooseFinalContent(rebuilt, rawContent) {
+      if (!Array.isArray(rawContent))
+        return rebuilt;
+      const hasServerSideBlocks = rawContent.some((b) => b && b.type !== "text" && b.type !== "tool_use");
+      if (hasServerSideBlocks)
+        return rawContent;
+      if (rebuilt.length === 0 && rawContent.length > 0)
+        return rawContent;
+      return rebuilt;
+    }
     function authHeaders() {
       const token = (0, index_1.getToken)();
       if (!token) {
@@ -9828,103 +9884,265 @@ var require_client = __commonJS({
         Authorization: `Bearer ${token}`
       };
     }
-    var MAX_RETRIES = 3;
+    var MAX_RETRIES = 5;
     var RETRY_BASE_MS = 1e3;
+    var RETRY_MAX_MS = 3e4;
+    var MAX_TOTAL_RETRY_MS = (() => {
+      const raw = Number(process.env.NEXRALL_MAX_RETRY_MS);
+      return Number.isFinite(raw) && raw > 0 ? raw : 5 * 6e4;
+    })();
+    function backoffMs(attempt) {
+      const exp = Math.min(RETRY_MAX_MS, RETRY_BASE_MS * Math.pow(2, attempt));
+      return Math.round(exp / 2 + Math.random() * (exp / 2));
+    }
     function sleep(ms) {
       return new Promise((r2) => setTimeout(r2, ms));
     }
+    var MAX_TOTAL_ATTEMPTS = (MAX_RETRIES + 1) * (MAX_RETRIES + 1);
     async function streamChat(messages, options, onEvent) {
-      const { model, env: env2, editorContext, nexrallMd, mode, effort, clientType, abortSignal, extraTools, agents } = options;
+      const { model, env: env2, editorContext, nexrallMd, mode, effort, clientType, abortSignal, extraTools, agents, skills, allowRestartAfterRender } = options;
+      let turnId = (0, crypto_1.randomUUID)();
       const controller = new AbortController();
       if (abortSignal?.aborted)
         throw Object.assign(new Error("Aborted"), { name: "AbortError" });
       let abortPoll;
+      let cancelSent = false;
       if (abortSignal) {
         abortPoll = setInterval(() => {
-          if (abortSignal.aborted)
-            controller.abort();
+          if (!abortSignal.aborted)
+            return;
+          if (cancelSent)
+            return;
+          cancelSent = true;
+          void cancelTurn(turnId);
+          controller.abort();
         }, 50);
       }
-      const fetchArgs = [
-        `${exports2.API_BASE}/api/code/chat`,
-        {
-          method: "POST",
-          headers: authHeaders(),
-          body: JSON.stringify({ messages, model, env: env2, editorContext, nexrallMd, mode, effort, clientType, extraTools, agents }),
-          signal: controller.signal
+      let serverResumable = false;
+      let lastEventId = 0;
+      let resuming = false;
+      let carryText = [];
+      let carryToolUse = [];
+      let emittedAnythingAcrossAttempts = false;
+      let emittedCharsAcrossAttempts = 0;
+      const buildFetchArgs = () => {
+        if (resuming) {
+          return [
+            `${exports2.API_BASE}/api/code/chat/resume?turnId=${encodeURIComponent(turnId)}`,
+            {
+              method: "GET",
+              headers: { ...authHeaders(), "Last-Event-ID": String(lastEventId) },
+              signal: controller.signal
+            }
+          ];
         }
-      ];
+        return [
+          `${exports2.API_BASE}/api/code/chat`,
+          {
+            method: "POST",
+            headers: authHeaders(),
+            body: JSON.stringify({ messages, model, env: env2, editorContext, nexrallMd, mode, effort, clientType, extraTools, agents, skills, turnId }),
+            signal: controller.signal
+          }
+        ];
+      };
       const isRetryableStreamMsg = (m2) => /overloaded|rate.?limit|temporarily|unavailable|try again|internal server error/i.test(String(m2 ?? ""));
+      let didRetry = false;
+      let totalAttemptsMade = 0;
+      let retryDeadline = 0;
+      const retryBudgetLeft = () => retryDeadline === 0 ? MAX_TOTAL_RETRY_MS : retryDeadline - Date.now();
+      const canRetry = () => retryBudgetLeft() > RETRY_BASE_MS;
+      const sleepWithinBudget = (ms) => sleep(Math.max(0, Math.min(ms, retryBudgetLeft())));
+      const reportRetry = (reason) => {
+        if (retryDeadline === 0)
+          retryDeadline = Date.now() + MAX_TOTAL_RETRY_MS;
+        totalAttemptsMade++;
+        didRetry = true;
+        onEvent({ type: "retry", attempt: totalAttemptsMade, maxAttempts: MAX_TOTAL_ATTEMPTS, reason });
+      };
+      const clearRetryIfNeeded = () => {
+        if (didRetry) {
+          didRetry = false;
+          onEvent({ type: "retry_resolved" });
+        }
+      };
       async function runAttempt() {
         let response;
         let lastErr;
+        let inFlightWaits = 0;
+        let errorBodyOverride = null;
+        let forbiddenExhausted = false;
         for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
           try {
-            response = await (0, node_fetch_1.default)(...fetchArgs);
-            if (response.status === 429 && attempt < MAX_RETRIES) {
+            response = await (0, node_fetch_1.default)(...buildFetchArgs());
+            if (response.status === 429 && attempt < MAX_RETRIES && canRetry()) {
+              reportRetry("Rate limited by the API \u2014 retrying");
               const retryAfter = parseInt(response.headers.get("retry-after") ?? "0", 10);
-              await sleep(retryAfter > 0 ? retryAfter * 1e3 : RETRY_BASE_MS * Math.pow(2, attempt));
+              await sleepWithinBudget(retryAfter > 0 ? retryAfter * 1e3 : backoffMs(attempt));
               continue;
             }
-            if (response.status >= 500 && response.status < 600 && attempt < MAX_RETRIES) {
-              await sleep(RETRY_BASE_MS * Math.pow(2, attempt));
+            if (response.status >= 500 && response.status < 600 && attempt < MAX_RETRIES && canRetry()) {
+              reportRetry(`Server error (${response.status}) \u2014 retrying`);
+              await sleepWithinBudget(backoffMs(attempt));
               continue;
             }
+            const FORBIDDEN_RETRY_LIMIT = 2;
+            if (response.status === 403) {
+              const bodyText = await response.text().catch(() => "");
+              let isUpstreamForbidden = false;
+              try {
+                const parsed = JSON.parse(bodyText);
+                isUpstreamForbidden = parsed?.error?.type === "forbidden";
+              } catch {
+              }
+              if (isUpstreamForbidden) {
+                if (attempt < FORBIDDEN_RETRY_LIMIT && canRetry()) {
+                  reportRetry("Upstream rejected the request \u2014 retrying");
+                  await sleepWithinBudget(backoffMs(attempt));
+                  continue;
+                }
+                forbiddenExhausted = true;
+                errorBodyOverride = bodyText;
+                break;
+              }
+              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;
+              }
+              errorBodyOverride = JSON.stringify({ error: "Could not resume this turn \u2014 send your message again." });
+              break;
+            }
+            if (response.status === 409) {
+              const body = await response.text();
+              let inFlight = false;
+              try {
+                inFlight = JSON.parse(body)?.turnInFlight === true;
+              } catch {
+              }
+              if (inFlight && canRetry()) {
+                inFlightWaits++;
+                reportRetry("This turn is already being processed \u2014 waiting for it");
+                const retryAfter = parseInt(response.headers.get("retry-after") ?? "0", 10);
+                await sleepWithinBudget(Math.max(retryAfter * 1e3, backoffMs(inFlightWaits)));
+                attempt--;
+                continue;
+              }
+              errorBodyOverride = body;
+              break;
+            }
             break;
           } catch (err) {
             if (err.name === "AbortError")
               throw err;
             lastErr = err;
-            if (attempt < MAX_RETRIES) {
-              await sleep(RETRY_BASE_MS * Math.pow(2, attempt));
+            if (attempt < MAX_RETRIES && canRetry()) {
+              reportRetry("Connection lost \u2014 attempting to reconnect");
+              await sleepWithinBudget(backoffMs(attempt));
               continue;
             }
+            if (!canRetry() && lastErr && typeof lastErr === "object") {
+              Object.assign(lastErr, { retryable: true });
+            }
+            break;
           }
         }
         if (!response)
           throw lastErr ?? new Error("Request failed after max retries");
         if (!response.ok) {
-          const errText = await response.text();
+          const errText = errorBodyOverride ?? await response.text();
           let errMsg = `API error ${response.status}`;
+          let balance;
           try {
             const parsed = JSON.parse(errText);
             if (parsed.error)
               errMsg = parsed.error;
+            if (typeof parsed.balance === "number")
+              balance = parsed.balance;
           } catch {
             errMsg = errText || errMsg;
           }
-          throw new Error(errMsg);
+          throw Object.assign(new Error(errMsg), { status: response.status, balance, ...forbiddenExhausted ? { retryable: true } : {} });
         }
         if (!response.body) {
           throw new Error("Response body is null");
         }
-        const textParts = [];
-        const toolUseBlocks = [];
+        const textParts = resuming ? [...carryText] : [];
+        const toolUseBlocks = resuming ? [...carryToolUse] : [];
         let completedMessage = null;
+        carryText = textParts;
+        carryToolUse = toolUseBlocks;
         let emittedToCaller = false;
+        let emittedChars = 0;
+        const tagTransient = (err) => {
+          if (!emittedToCaller)
+            return Object.assign(err, { retryable: true });
+          if (allowRestartAfterRender) {
+            return Object.assign(err, { retryable: true, needsRestart: true, discardedChars: emittedChars });
+          }
+          return err;
+        };
+        const haveCompleteMessage = () => completedMessage !== null;
         const partialInputs = {};
         await new Promise((resolve3, reject) => {
           const stream = response.body;
-          const HEARTBEAT_TIMEOUT_MS = 45e3;
-          const FIRST_EVENT_TIMEOUT_MS = 3e5;
-          const PROGRESS_TIMEOUT_MS = 15e4;
+          const HEARTBEAT_TIMEOUT_MS = 9e4;
+          const FIRST_EVENT_TIMEOUT_MS = Number(process.env.NEXRALL_FIRST_EVENT_TIMEOUT_MS) || 3e5;
+          const PROGRESS_TIMEOUT_MS = Number(process.env.NEXRALL_PROGRESS_TIMEOUT_MS) || 15e4;
           let sawModelEvent = false;
           let lastDataAt = Date.now();
           let lastProgressAt = Date.now();
           const heartbeatWatchdog = setInterval(() => {
             const now = Date.now();
+            if (haveCompleteMessage() && now - lastDataAt > HEARTBEAT_TIMEOUT_MS) {
+              clearInterval(heartbeatWatchdog);
+              stream.destroy?.();
+              resolve3();
+              return;
+            }
             if (now - lastDataAt > HEARTBEAT_TIMEOUT_MS) {
               clearInterval(heartbeatWatchdog);
               stream.destroy?.();
-              reject(new Error("Connection lost \u2014 no data received for 45 s. Retry your message."));
+              const recoverable = !emittedToCaller || !!allowRestartAfterRender;
+              const secs = Math.round(HEARTBEAT_TIMEOUT_MS / 1e3);
+              reject(tagTransient(new Error(recoverable ? `Connection lost \u2014 no data received for ${secs} s. Reconnecting\u2026` : `Connection lost \u2014 no data received for ${secs} s. Retry your message.`)));
               return;
             }
             const stallLimitMs = sawModelEvent ? PROGRESS_TIMEOUT_MS : FIRST_EVENT_TIMEOUT_MS;
             if (now - lastProgressAt > stallLimitMs) {
               clearInterval(heartbeatWatchdog);
               stream.destroy?.();
-              const stallErr = new Error(sawModelEvent ? `The model stopped responding mid-stream (no output for ${Math.round(stallLimitMs / 1e3)} s). Retry your message.` : `The model did not start responding within ${Math.round(stallLimitMs / 1e3)} s (large context can take a while to process). Retry your message.`);
-              reject(emittedToCaller ? stallErr : Object.assign(stallErr, { retryable: true }));
+              if (haveCompleteMessage()) {
+                resolve3();
+                return;
+              }
+              reject(tagTransient(new Error(sawModelEvent ? `The model stopped responding mid-stream (no output for ${Math.round(stallLimitMs / 1e3)} s).` : `The model did not start responding within ${Math.round(stallLimitMs / 1e3)} s (large context can take a while to process).`)));
               return;
             }
           }, 5e3);
@@ -9934,6 +10152,12 @@ var require_client = __commonJS({
               return;
             }
             {
+              const frameId = event.id;
+              if (frameId) {
+                const n = Number(frameId);
+                if (Number.isFinite(n) && n > lastEventId)
+                  lastEventId = n;
+              }
               const raw = event.data;
               if (!raw || raw === "[DONE]") {
                 resolve3();
@@ -9951,11 +10175,15 @@ var require_client = __commonJS({
               const evt = parsed;
               lastProgressAt = Date.now();
               sawModelEvent = true;
+              clearRetryIfNeeded();
               switch (evt.type) {
                 case "text": {
                   const text = typeof evt.text === "string" ? evt.text : "";
                   textParts.push(text);
                   emittedToCaller = true;
+                  emittedChars += text.length;
+                  emittedAnythingAcrossAttempts = true;
+                  emittedCharsAcrossAttempts += text.length;
                   onEvent({ type: "text", text });
                   break;
                 }
@@ -9976,19 +10204,25 @@ var require_client = __commonJS({
                   }
                   toolUseBlocks.push(block);
                   emittedToCaller = true;
+                  emittedAnythingAcrossAttempts = true;
                   onEvent({ type: "tool_use", id: block.id, name: block.name, input: block.input });
                   break;
                 }
                 case "message_complete": {
+                  const nestedMessage = evt.message;
+                  const stopReason = typeof nestedMessage?.stop_reason === "string" ? nestedMessage.stop_reason : null;
                   const contentBlocks2 = [];
                   const fullText2 = textParts.join("");
                   if (fullText2) {
                     contentBlocks2.push({ type: "text", text: fullText2 });
                   }
                   contentBlocks2.push(...toolUseBlocks);
+                  const rawContent = Array.isArray(nestedMessage?.content) ? nestedMessage.content : null;
+                  const finalContent = chooseFinalContent(contentBlocks2, rawContent);
                   completedMessage = {
                     role: "assistant",
-                    content: contentBlocks2
+                    content: finalContent,
+                    stopReason
                   };
                   onEvent({ type: "message_complete", message: completedMessage });
                   break;
@@ -9997,6 +10231,17 @@ var require_client = __commonJS({
                   if (typeof evt.input_tokens === "number" && typeof evt.output_tokens === "number") {
                     onEvent({
                       type: "usage",
+                      // Forwarded, not dropped: the backend tags the usage of an attempt it
+                      // billed but never completed (its stream `abort` path). Without this
+                      // the flag dies here and every consumer that sums usage silently folds
+                      // a discarded attempt's tokens into the successful turn's total.
+                      ...evt.partial === true ? { partial: true } : {},
+                      // `replayed` means these tokens are being reported a SECOND time: the
+                      // turn completed and was billed on an earlier attempt whose `done` never
+                      // reached us, and the backend served this one from its idempotency cache
+                      // instead of re-running the model. Nothing new was charged, so a cost
+                      // display must not add them again.
+                      ...evt.replayed === true ? { replayed: true } : {},
                       usage: {
                         input_tokens: evt.input_tokens,
                         output_tokens: evt.output_tokens,
@@ -10017,6 +10262,9 @@ var require_client = __commonJS({
                   const text = typeof evt.text === "string" ? evt.text : "";
                   if (text) {
                     emittedToCaller = true;
+                    emittedChars += text.length;
+                    emittedAnythingAcrossAttempts = true;
+                    emittedCharsAcrossAttempts += text.length;
                     onEvent({ type: "thinking", text });
                   }
                   break;
@@ -10030,10 +10278,23 @@ var require_client = __commonJS({
                   const text = typeof evt.text === "string" ? evt.text : "";
                   if (text) {
                     emittedToCaller = true;
+                    emittedChars += text.length;
+                    emittedAnythingAcrossAttempts = true;
+                    emittedCharsAcrossAttempts += text.length;
                     onEvent({ type: "thinking_delta", text });
                   }
                   break;
                 }
+                case "resumable": {
+                  serverResumable = true;
+                  break;
+                }
+                case "balance_status": {
+                  const balance = typeof evt.balance === "number" ? evt.balance : 0;
+                  const zero = !!evt.zero;
+                  onEvent({ type: "balance_status", balance, zero });
+                  break;
+                }
                 case "done": {
                   onEvent({ type: "done" });
                   resolve3();
@@ -10041,10 +10302,19 @@ var require_client = __commonJS({
                 }
                 case "error": {
                   const message = typeof evt.message === "string" ? evt.message : typeof evt.error === "string" ? evt.error : "Unknown SSE error";
-                  if (isRetryableStreamMsg(message) && !emittedToCaller) {
+                  const notResumable = evt.notResumable === true;
+                  if (haveCompleteMessage()) {
+                    clearInterval(heartbeatWatchdog);
+                    onEvent({ type: "error", message });
+                    resolve3();
+                  } else if (notResumable && (!emittedToCaller || allowRestartAfterRender)) {
                     clearInterval(heartbeatWatchdog);
                     stream.destroy?.();
-                    reject(Object.assign(new Error(message), { retryable: true }));
+                    reject(Object.assign(tagTransient(new Error(message)), { forceRestart: true }));
+                  } else if (isRetryableStreamMsg(message) && (!emittedToCaller || allowRestartAfterRender)) {
+                    clearInterval(heartbeatWatchdog);
+                    stream.destroy?.();
+                    reject(tagTransient(new Error(message)));
                   } else {
                     onEvent({ type: "error", message });
                     reject(new Error(message));
@@ -10076,11 +10346,11 @@ var require_client = __commonJS({
               resolve3();
               return;
             }
-            if (!emittedToCaller) {
-              reject(Object.assign(err, { retryable: true }));
+            if (haveCompleteMessage()) {
+              resolve3();
               return;
             }
-            reject(err);
+            reject(tagTransient(err));
           });
         });
         if (completedMessage) {
@@ -10097,14 +10367,60 @@ var require_client = __commonJS({
       try {
         for (let sAttempt = 0; sAttempt <= MAX_RETRIES; sAttempt++) {
           try {
-            return await runAttempt();
+            const result = await runAttempt();
+            clearRetryIfNeeded();
+            return result;
           } catch (err) {
             if (abortSignal?.aborted || controller.signal.aborted || err.name === "AbortError")
               throw err;
-            if (err.retryable && sAttempt < MAX_RETRIES) {
-              await sleep(RETRY_BASE_MS * Math.pow(2, sAttempt));
+            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) {
+                  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;
+              }
+              if (serverResumable && lastEventId > 0) {
+                resuming = true;
+                reportRetry(err.message || "Connection interrupted \u2014 resuming");
+                await sleepWithinBudget(backoffMs(sAttempt));
+                continue;
+              }
+              if (e2.needsRestart) {
+                onEvent({
+                  type: "stream_restart",
+                  reason: err.message || "Connection interrupted",
+                  discardedChars: e2.discardedChars ?? 0
+                });
+              }
+              reportRetry(err.message || "Connection interrupted \u2014 reconnecting");
+              await sleepWithinBudget(backoffMs(sAttempt));
               continue;
             }
+            if (e2.retryable && !canRetry()) {
+              throw Object.assign(new Error(`${err.message} \u2014 gave up after ${Math.round(MAX_TOTAL_RETRY_MS / 6e4)} minutes of reconnect attempts. Check your connection and resend; completed work in this turn is preserved.`), { retryBudgetExhausted: true });
+            }
             throw err;
           }
         }
@@ -10114,6 +10430,16 @@ var require_client = __commonJS({
           clearInterval(abortPoll);
       }
     }
+    async function cancelTurn(turnId) {
+      try {
+        await (0, node_fetch_1.default)(`${exports2.API_BASE}/api/code/chat/cancel`, {
+          method: "POST",
+          headers: { ...authHeaders(), "Content-Type": "application/json" },
+          body: JSON.stringify({ turnId })
+        });
+      } catch {
+      }
+    }
     async function getBalance3() {
       const response = await (0, node_fetch_1.default)(`${exports2.API_BASE}/api/code/balance`, {
         method: "GET",
@@ -10360,123 +10686,887 @@ var require_editCompleteness = __commonJS({
   }
 });
 
-// ../core/dist/agent/testIntegrity.js
-var require_testIntegrity = __commonJS({
-  "../core/dist/agent/testIntegrity.js"(exports2) {
+// ../core/dist/agent/memory.js
+var require_memory = __commonJS({
+  "../core/dist/agent/memory.js"(exports2) {
     "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m2, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m2, k);
+      if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m2[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m2, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m2[k];
+    });
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2)
+            if (Object.prototype.hasOwnProperty.call(o2, k))
+              ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule)
+          return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i2 = 0; i2 < k.length; i2++)
+            if (k[i2] !== "default")
+              __createBinding(result, mod, k[i2]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    }();
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.isTestFile = isTestFile;
-    exports2.analyzeTestEdit = analyzeTestEdit;
-    exports2.analyzeWriteToolForTestIntegrity = analyzeWriteToolForTestIntegrity;
-    exports2.encodeTestIntegrityMarker = encodeTestIntegrityMarker;
-    exports2.decodeTestIntegrityMarker = decodeTestIntegrityMarker;
-    exports2.stripTestIntegrityMarker = stripTestIntegrityMarker;
-    var TEST_PATH_RE = /(?:^|[\/\\])(?:tests?|spec|__tests__|testing)[\/\\]|(?:\.|_|-)(?:test|spec|tests)\.[a-z]+$|(?:^|[\/\\])test_[^\/\\]+\.py$|(?:^|[\/\\])[^\/\\]+_test\.(?:go|py|rb)$|Test[^\/\\]*\.(?:java|kt|cs)$|(?:^|[\/\\])[^\/\\]*Tests?\.(?:java|kt|cs)$/i;
-    function isTestFile(path5) {
-      if (!path5 || typeof path5 !== "string")
-        return false;
-      return TEST_PATH_RE.test(path5);
-    }
-    var ASSERTION_RES = [
-      /\bexpect\s*\(/g,
-      // jest / chai / vitest / jasmine
-      /\bassert(?:Equals?|True|False|That|Null|NotNull|Same)?\b/g,
-      // junit / python unittest / generic
-      /\bassert\s*[.(]/g,
-      // node:assert (assert.equal / assert( ) )
-      /\.should\b/g,
-      // chai should / rspec should
-      /\bshould\s*[.(]/g,
-      /\bEXPECT_[A-Z]+\s*\(/g,
-      // gtest
-      /\bASSERT_[A-Z]+\s*\(/g,
-      // gtest
-      /\brequire\.\w+\s*\(/g,
-      // testify require
-      /\bassert\.\w+\s*\(/g,
-      // testify assert
-      /\bt\.(?:Error|Fatal|Errorf|Fatalf)\b/g,
-      // go testing
-      /\bassert!\s*\(|\bassert_eq!\s*\(|\bassert_ne!\s*\(/g
-      // rust
-    ];
-    var TESTCASE_RES = [
-      /\b(?:it|test)\s*\(/g,
-      // jest / mocha / jasmine
-      /\bdef\s+test_\w+/g,
-      // python
-      /\bfunc\s+Test\w+/g,
-      // go
-      /@Test\b/g,
-      // junit
-      /\bfn\s+\w*test\w*\s*\(/gi
-      // rust (best-effort)
-    ];
-    var SKIP_RES = [
-      /\b(?:it|test|describe|context|suite)\s*\.\s*(?:skip|only)\b/g,
-      /\bx(?:it|describe|test|context)\s*\(/g,
-      // xit / xdescribe
-      /\bf(?:it|describe)\s*\(/g,
-      // fit / fdescribe (focus)
-      /@pytest\.mark\.skip\b|@pytest\.mark\.skipif\b|@unittest\.skip\b|@skip\b/g,
-      /\bpytest\.skip\s*\(/g,
-      /\bt\.Skip\s*\(|\bt\.SkipNow\s*\(/g,
-      // go
-      /@Disabled\b|@Ignore\b/g,
-      // junit / kotlin
-      /\.only\s*\(/g
-      // test.only leaks CI coverage
-    ];
-    var TAUTOLOGY_RES = [
-      /\bassert\s+True\b|\bassert\s+1\b|\bassert\s+not\s+False\b/g,
-      // python
-      /\bassert\s*\(\s*true\s*\)|\bassert\.ok\s*\(\s*true\s*\)/gi,
-      // node
-      /\bexpect\s*\(\s*true\s*\)\s*\.\s*to(?:Be|Equal|BeTruthy)\s*\(\s*true\s*\)?/gi,
-      // jest
-      /\bexpect\s*\(\s*(\w+)\s*\)\s*\.\s*toBe\s*\(\s*\1\s*\)/g,
-      // expect(x).toBe(x)
-      /\bassert_eq!\s*\(\s*true\s*,\s*true\s*\)/g,
-      // rust
-      /\bassert!\s*\(\s*true\s*\)/g
-    ];
-    function countMatches(res, text) {
-      let n = 0;
-      for (const re of res) {
-        re.lastIndex = 0;
-        const m2 = text.match(re);
-        if (m2)
-          n += m2.length;
+    exports2.MEMORY_HARD_CAP_BYTES = exports2.MEMORY_COMPACT_TRIGGER_BYTES = exports2.MEMORY_MAX_BYTES = exports2.MEMORY_ENTRY_MAX_CHARS = void 0;
+    exports2.memoryFilePath = memoryFilePath;
+    exports2.writeMemory = writeMemory;
+    exports2.readMemory = readMemory2;
+    exports2.readAllMemory = readAllMemory2;
+    exports2.clearMemory = clearMemory2;
+    exports2.memoryStats = memoryStats2;
+    exports2.compactMemoryIfNeeded = compactMemoryIfNeeded2;
+    var fs6 = __importStar(require("fs"));
+    var os5 = __importStar(require("os"));
+    var path5 = __importStar(require("path"));
+    var crypto2 = __importStar(require("crypto"));
+    var MEMORY_ROOT = process.env.NEXRALL_MEMORY_DIR || path5.join(os5.homedir(), ".nexrall", "memory");
+    var GLOBAL_FILE = path5.join(MEMORY_ROOT, "global.md");
+    function memoryFilePath(scope, workDir) {
+      if (scope === "global" || !workDir)
+        return GLOBAL_FILE;
+      const key = crypto2.createHash("sha1").update(path5.resolve(workDir)).digest("hex").slice(0, 16);
+      return path5.join(MEMORY_ROOT, `project-${key}.md`);
+    }
+    exports2.MEMORY_ENTRY_MAX_CHARS = 400;
+    exports2.MEMORY_MAX_BYTES = 12e3;
+    exports2.MEMORY_COMPACT_TRIGGER_BYTES = 16e3;
+    exports2.MEMORY_HARD_CAP_BYTES = 4 * exports2.MEMORY_COMPACT_TRIGGER_BYTES;
+    var FINGERPRINT_LEN = 60;
+    var _locks = /* @__PURE__ */ new Map();
+    async function withLock(key, fn) {
+      const prev = _locks.get(key) ?? Promise.resolve();
+      let release2;
+      const next = new Promise((res) => {
+        release2 = res;
+      });
+      _locks.set(key, prev.then(() => next));
+      try {
+        await prev;
+        return await fn();
+      } finally {
+        release2();
+        if (_locks.get(key) === next)
+          _locks.delete(key);
       }
-      return n;
     }
-    function countCommentedOutTestLines(oldText, newText) {
-      const oldLines = new Set(oldText.split("\n").map((l) => l.trim()));
-      let n = 0;
-      for (const raw of newText.split("\n")) {
-        const line = raw.trim();
-        const isComment = /^(?:\/\/|#|\/\*|\*)/.test(line);
-        if (!isComment)
-          continue;
-        const body = line.replace(/^(?:\/\/+|#+|\/\*+|\*+)\s?/, "");
-        const looksLikeTest = /\b(expect|assert|it\(|test\(|def test_|func Test|EXPECT_|ASSERT_)\b/.test(body);
-        if (looksLikeTest && oldLines.has(body))
-          n += 1;
+    function readMemoryFile(file) {
+      try {
+        return fs6.readFileSync(file, "utf-8");
+      } catch {
+        return "";
       }
-      return n;
     }
-    function analyzeTestEdit(path5, oldText, newText) {
-      if (!isTestFile(path5)) {
-        return { isTestFile: false, suspicious: false, findings: [] };
+    function writeMemoryFile(file, content) {
+      fs6.mkdirSync(path5.dirname(file), { recursive: true });
+      fs6.writeFileSync(file, content, "utf-8");
+    }
+    function evictOldest(content, maxBytes) {
+      if (Buffer.byteLength(content, "utf-8") <= maxBytes)
+        return content;
+      const lines = content.split("\n").filter((l) => l.trim().length > 0);
+      while (lines.length > 1 && Buffer.byteLength(lines.join("\n"), "utf-8") > maxBytes)
+        lines.shift();
+      return "\n" + lines.join("\n");
+    }
+    async function writeMemory(content, scope, workDir) {
+      let trimmed = content.trim();
+      if (!trimmed)
+        return { ok: false, already: false, scope, file: "" };
+      if (trimmed.length > exports2.MEMORY_ENTRY_MAX_CHARS)
+        trimmed = trimmed.slice(0, exports2.MEMORY_ENTRY_MAX_CHARS - 1).trimEnd() + "\u2026";
+      const file = memoryFilePath(scope, workDir);
+      return withLock(file, async () => {
+        const existing = readMemoryFile(file);
+        const fingerprint = trimmed.toLowerCase().slice(0, FINGERPRINT_LEN);
+        if (existing.toLowerCase().includes(fingerprint)) {
+          return { ok: true, already: true, scope, file };
+        }
+        const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+        let next = existing + `
+- [${today}] ${trimmed}`;
+        if (Buffer.byteLength(next, "utf-8") > exports2.MEMORY_HARD_CAP_BYTES) {
+          next = evictOldest(next, exports2.MEMORY_MAX_BYTES);
+        }
+        writeMemoryFile(file, next);
+        return { ok: true, already: false, scope, file };
+      });
+    }
+    function readMemory2(scope, workDir) {
+      const file = memoryFilePath(scope, workDir);
+      return readMemoryFile(file).trim();
+    }
+    function readAllMemory2(workDir) {
+      const parts = [];
+      const globalMem = readMemory2("global");
+      if (globalMem)
+        parts.push(`[Global memories \u2014 apply to every project]
+${globalMem}`);
+      if (workDir) {
+        const projMem = readMemory2("project", workDir);
+        if (projMem)
+          parts.push(`[Project memories \u2014 ${path5.basename(path5.resolve(workDir))}]
+${projMem}`);
+      }
+      return parts.join("\n\n");
+    }
+    function clearMemory2(scope, workDir) {
+      const file = memoryFilePath(scope, workDir);
+      try {
+        fs6.rmSync(file, { force: true });
+      } catch {
       }
-      const findings = [];
-      const skipsBefore = countMatches(SKIP_RES, oldText);
-      const skipsAfter = countMatches(SKIP_RES, newText);
-      if (skipsAfter > skipsBefore) {
-        findings.push({
-          kind: "skip-added",
-          reason: `added ${skipsAfter - skipsBefore} skip/only/disabled marker(s) \u2014 tests are being skipped, not fixed`
-        });
+    }
+    function memoryStats2(scope, workDir) {
+      const file = memoryFilePath(scope, workDir);
+      const content = readMemoryFile(file);
+      const entries = content.split("\n").filter((l) => /^-\s\[\d{4}-\d{2}-\d{2}\]/.test(l)).length;
+      return { file, bytes: Buffer.byteLength(content, "utf-8"), entries };
+    }
+    async function compactMemoryIfNeeded2(scope, workDir, summarize) {
+      const file = memoryFilePath(scope, workDir);
+      return withLock(file, async () => {
+        const content = readMemoryFile(file);
+        if (Buffer.byteLength(content, "utf-8") <= exports2.MEMORY_COMPACT_TRIGGER_BYTES)
+          return false;
+        const lines = content.split("\n").filter((l) => l.trim().length > 0);
+        if (lines.length < 8)
+          return false;
+        const cut = Math.floor(lines.length / 2);
+        const older = lines.slice(0, cut);
+        const recent = lines.slice(cut);
+        const prompt2 = `Consolidate these persistent-memory bullet entries into a shorter set of bullets, merging duplicates/near-duplicates and dropping anything clearly stale or superseded by a later entry. Keep each resulting bullet under ${exports2.MEMORY_ENTRY_MAX_CHARS} characters, one fact per line, prefixed "- [YYYY-MM-DD] " using the LATEST date among the entries it draws from. Output ONLY the bullet lines, nothing else.
+
+${older.join("\n")}`;
+        let summarized;
+        try {
+          summarized = (await summarize(prompt2)).trim();
+        } catch {
+          return false;
+        }
+        if (!summarized)
+          return false;
+        const next = summarized + "\n" + recent.join("\n");
+        writeMemoryFile(file, Buffer.byteLength(next, "utf-8") > exports2.MEMORY_MAX_BYTES ? evictOldest(next, exports2.MEMORY_MAX_BYTES) : next);
+        return true;
+      });
+    }
+  }
+});
+
+// ../core/dist/plugins/index.js
+var require_plugins = __commonJS({
+  "../core/dist/plugins/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m2, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m2, k);
+      if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m2[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m2, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m2[k];
+    });
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2)
+            if (Object.prototype.hasOwnProperty.call(o2, k))
+              ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule)
+          return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i2 = 0; i2 < k.length; i2++)
+            if (k[i2] !== "default")
+              __createBinding(result, mod, k[i2]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    }();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.loadPlugins = loadPlugins3;
+    exports2.pluginAssetDirs = pluginAssetDirs;
+    exports2.pluginHooks = pluginHooks;
+    exports2.pluginMcpServers = pluginMcpServers;
+    var fs6 = __importStar(require("fs"));
+    var path5 = __importStar(require("path"));
+    var os5 = __importStar(require("os"));
+    function readMeta(dir) {
+      try {
+        const raw = fs6.readFileSync(path5.join(dir, "plugin.json"), "utf-8");
+        const j = JSON.parse(raw);
+        return {
+          name: typeof j.name === "string" ? j.name : void 0,
+          version: typeof j.version === "string" ? j.version : void 0,
+          description: typeof j.description === "string" ? j.description : void 0
+        };
+      } catch {
+        return {};
+      }
+    }
+    function scanRoot(root, scope, into) {
+      let entries;
+      try {
+        entries = fs6.readdirSync(root, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (!entry.isDirectory() && !entry.isSymbolicLink())
+          continue;
+        const dir = path5.join(root, entry.name);
+        try {
+          if (!fs6.statSync(dir).isDirectory())
+            continue;
+        } catch {
+          continue;
+        }
+        const meta = readMeta(dir);
+        const name = meta.name || entry.name;
+        if (into.has(name))
+          continue;
+        into.set(name, { name, version: meta.version, description: meta.description, dir, scope });
+      }
+    }
+    function loadPlugins3(workDir) {
+      const out = /* @__PURE__ */ new Map();
+      scanRoot(path5.join(workDir, ".nexrall", "plugins"), "project", out);
+      scanRoot(path5.join(os5.homedir(), ".nexrall", "plugins"), "global", out);
+      return [...out.values()];
+    }
+    function pluginAssetDirs(workDir, kind) {
+      return loadPlugins3(workDir).map((p) => path5.join(p.dir, kind)).filter((d) => {
+        try {
+          return fs6.statSync(d).isDirectory();
+        } catch {
+          return false;
+        }
+      });
+    }
+    function pluginHooks(workDir) {
+      const merged = {};
+      for (const p of loadPlugins3(workDir)) {
+        try {
+          const raw = fs6.readFileSync(path5.join(p.dir, "hooks.json"), "utf-8");
+          const j = JSON.parse(raw);
+          const hooks = j.hooks ?? j;
+          for (const [phase, entries] of Object.entries(hooks)) {
+            if (!Array.isArray(entries))
+              continue;
+            merged[phase] = [...merged[phase] ?? [], ...entries];
+          }
+        } catch {
+        }
+      }
+      return merged;
+    }
+    function pluginMcpServers(workDir) {
+      const merged = {};
+      for (const p of loadPlugins3(workDir)) {
+        try {
+          const raw = fs6.readFileSync(path5.join(p.dir, "mcp.json"), "utf-8");
+          const j = JSON.parse(raw);
+          const servers = j.mcpServers ?? j;
+          for (const [name, cfg] of Object.entries(servers)) {
+            if (!(name in merged))
+              merged[name] = cfg;
+          }
+        } catch {
+        }
+      }
+      return merged;
+    }
+  }
+});
+
+// ../core/dist/commands/loader.js
+var require_loader = __commonJS({
+  "../core/dist/commands/loader.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m2, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m2, k);
+      if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m2[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m2, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m2[k];
+    });
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2)
+            if (Object.prototype.hasOwnProperty.call(o2, k))
+              ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule)
+          return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i2 = 0; i2 < k.length; i2++)
+            if (k[i2] !== "default")
+              __createBinding(result, mod, k[i2]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    }();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.loadSlashCommands = loadSlashCommands;
+    exports2.findSlashCommand = findSlashCommand;
+    exports2.expandBody = expandBody;
+    exports2.expandCommand = expandCommand;
+    var fs6 = __importStar(require("fs"));
+    var path5 = __importStar(require("path"));
+    var os5 = __importStar(require("os"));
+    var child_process_1 = require("child_process");
+    var index_1 = require_plugins();
+    var BUILTIN_COMMANDS = [
+      {
+        name: "review",
+        description: "Review uncommitted changes (or a PR/branch diff) for bugs and risks",
+        source: "builtin",
+        body: [
+          "Review the following diff like a meticulous senior engineer. Target: $ARGUMENTS",
+          "(If no target given, review the uncommitted working-tree changes below. If a branch or PR",
+          "number is given, run the appropriate `git diff <base>...` or `gh pr diff <n>` yourself first.)",
+          "",
+          "Branch: !`git branch --show-current`",
+          "Status: !`git status --short`",
+          "",
+          "Diff (uncommitted):",
+          "```diff",
+          "!`git diff HEAD --unified=5 --no-color | head -4000`",
+          "```",
+          "",
+          "Review methodology:",
+          "1. Read the surrounding code of every changed hunk (read_file with offset/limit) \u2014 never judge a hunk in isolation.",
+          "2. Look for: correctness bugs, edge cases (empty/null/unicode/concurrency), security issues",
+          "   (injection, path traversal, secrets), breaking API changes (find_references / search callers),",
+          "   silent behaviour changes, and missing error handling.",
+          "3. Check tests: do existing tests cover the change? Are assertions weakened?",
+          "",
+          "Output format:",
+          "- \u{1F534} Critical (must fix before merge) \u2014 with file:line and a concrete fix",
+          "- \u{1F7E1} Warning (should fix) \u2014 with file:line",
+          "- \u{1F7E2} Suggestion (nice to have)",
+          "- Verdict: APPROVE / REQUEST CHANGES with a one-paragraph summary.",
+          "Do NOT modify any files \u2014 this is a read-only review."
+        ].join("\n")
+      }
+    ];
+    function parseFrontmatter(raw) {
+      const m2 = /^\s*---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(raw);
+      if (!m2)
+        return { meta: {}, body: raw.trim() };
+      const meta = {};
+      for (const line of m2[1].split(/\r?\n/)) {
+        const kv = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/.exec(line.trim());
+        if (kv)
+          meta[kv[1].toLowerCase()] = kv[2].trim().replace(/^["']|["']$/g, "");
+      }
+      return { meta, body: (m2[2] ?? "").trim() };
+    }
+    function loadDir(dir, source, into) {
+      let files;
+      try {
+        files = fs6.readdirSync(dir).filter((f3) => f3.endsWith(".md"));
+      } catch {
+        return;
+      }
+      for (const file of files) {
+        try {
+          const raw = fs6.readFileSync(path5.join(dir, file), "utf-8");
+          const { meta, body } = parseFrontmatter(raw);
+          const name = (meta.name || path5.basename(file, ".md")).trim().toLowerCase();
+          if (!name)
+            continue;
+          if (source !== "project" && into.has(name))
+            continue;
+          const model = ["turbo", "pro", "ultra"].find((x2) => x2 === (meta.model ?? "").toLowerCase());
+          into.set(name, {
+            name,
+            description: meta.description || `Custom /${name} command`,
+            model,
+            mode: meta.mode || void 0,
+            body,
+            source
+          });
+        } catch {
+        }
+      }
+    }
+    function loadSlashCommands(workDir) {
+      const out = /* @__PURE__ */ new Map();
+      loadDir(path5.join(workDir, ".nexrall", "commands"), "project", out);
+      loadDir(path5.join(os5.homedir(), ".nexrall", "commands"), "global", out);
+      for (const dir of (0, index_1.pluginAssetDirs)(workDir, "commands"))
+        loadDir(dir, "plugin", out);
+      for (const cmd of BUILTIN_COMMANDS) {
+        if (!out.has(cmd.name))
+          out.set(cmd.name, cmd);
+      }
+      return [...out.values()];
+    }
+    function findSlashCommand(cmds, name) {
+      const want = name.replace(/^\//, "").trim().toLowerCase();
+      return cmds.find((c) => c.name === want);
+    }
+    function expandBody(body, argString, workDir) {
+      const args = argString.trim();
+      const positional = args ? args.split(/\s+/) : [];
+      let out = body;
+      out = out.replace(/!`([^`]+)`/g, (_m, c) => {
+        try {
+          const stdout = (0, child_process_1.execSync)(c, { cwd: workDir, encoding: "utf-8", timeout: 15e3, stdio: ["ignore", "pipe", "pipe"] });
+          return stdout.trim();
+        } catch (err) {
+          return `[command failed: ${c} \u2014 ${err.message}]`;
+        }
+      });
+      out = out.replace(/(^|\s)@([^\s]+)/g, (_m, lead, rel) => {
+        const abs = path5.isAbsolute(rel) ? rel : path5.join(workDir, rel);
+        try {
+          const content = fs6.readFileSync(abs, "utf-8").slice(0, 12e3);
+          return `${lead}
+[File: ${rel}]
+\`\`\`
+${content}
+\`\`\`
+`;
+        } catch {
+          return `${lead}[missing file: ${rel}]`;
+        }
+      });
+      out = out.replace(/\$(\d+)/g, (_m, n) => positional[Number(n) - 1] ?? "");
+      const hadArgsToken = /\$ARGUMENTS/.test(out);
+      out = out.replace(/\$ARGUMENTS/g, args);
+      if (!hadArgsToken && !/\$\d+/.test(body) && args) {
+        out = `${out}
+
+${args}`;
+      }
+      return out.trim();
+    }
+    function expandCommand(cmd, argString, workDir) {
+      return expandBody(cmd.body, argString, workDir);
+    }
+  }
+});
+
+// ../core/dist/agent/skills.js
+var require_skills = __commonJS({
+  "../core/dist/agent/skills.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m2, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m2, k);
+      if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m2[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m2, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m2[k];
+    });
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2)
+            if (Object.prototype.hasOwnProperty.call(o2, k))
+              ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule)
+          return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i2 = 0; i2 < k.length; i2++)
+            if (k[i2] !== "default")
+              __createBinding(result, mod, k[i2]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    }();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.loadSkills = loadSkills2;
+    exports2.findSkill = findSkill2;
+    exports2.autoInvokableSkills = autoInvokableSkills;
+    exports2.userInvokableSkills = userInvokableSkills2;
+    exports2.summariseSkills = summariseSkills;
+    exports2.expandSkill = expandSkill2;
+    var fs6 = __importStar(require("fs"));
+    var path5 = __importStar(require("path"));
+    var os5 = __importStar(require("os"));
+    var index_1 = require_plugins();
+    var loader_1 = require_loader();
+    function parseFrontmatter(raw) {
+      const m2 = /^\s*---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(raw);
+      if (!m2)
+        return { meta: {}, body: raw.trim() };
+      const meta = {};
+      for (const line of m2[1].split(/\r?\n/)) {
+        const kv = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/.exec(line.trim());
+        if (kv)
+          meta[kv[1].toLowerCase()] = kv[2].trim().replace(/^["']|["']$/g, "");
+      }
+      return { meta, body: (m2[2] ?? "").trim() };
+    }
+    function parseBool(v, fallback) {
+      if (v === void 0)
+        return fallback;
+      const s2 = v.trim().toLowerCase();
+      if (s2 === "true" || s2 === "1" || s2 === "yes")
+        return true;
+      if (s2 === "false" || s2 === "0" || s2 === "no")
+        return false;
+      return fallback;
+    }
+    function toSkill(meta, body, name, source, dir) {
+      const model = ["turbo", "pro", "ultra"].find((x2) => x2 === (meta.model ?? "").toLowerCase());
+      return {
+        name,
+        description: meta.description || `Custom /${name} skill`,
+        model,
+        mode: meta.mode || void 0,
+        body,
+        source,
+        dir,
+        disableModelInvocation: parseBool(meta["disable-model-invocation"], false),
+        userInvocable: parseBool(meta["user-invocable"], true)
+      };
+    }
+    function loadFlatCommandDir(dir, source, into) {
+      let files;
+      try {
+        files = fs6.readdirSync(dir).filter((f3) => f3.endsWith(".md"));
+      } catch {
+        return;
+      }
+      for (const file of files) {
+        try {
+          const raw = fs6.readFileSync(path5.join(dir, file), "utf-8");
+          const { meta, body } = parseFrontmatter(raw);
+          const name = (meta.name || path5.basename(file, ".md")).trim().toLowerCase();
+          if (!name)
+            continue;
+          if (source !== "project" && into.has(name))
+            continue;
+          into.set(name, toSkill(meta, body, name, source));
+        } catch {
+        }
+      }
+    }
+    function loadSkillDir(root, source, into) {
+      let entries;
+      try {
+        entries = fs6.readdirSync(root, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (!entry.isDirectory() && !entry.isSymbolicLink())
+          continue;
+        const skillDir = path5.join(root, entry.name);
+        const skillFile = path5.join(skillDir, "SKILL.md");
+        try {
+          if (!fs6.statSync(skillFile).isFile())
+            continue;
+        } catch {
+          continue;
+        }
+        try {
+          const raw = fs6.readFileSync(skillFile, "utf-8");
+          const { meta, body } = parseFrontmatter(raw);
+          const name = (meta.name || entry.name).trim().toLowerCase();
+          if (!name)
+            continue;
+          if (source !== "project" && into.has(name))
+            continue;
+          into.set(name, toSkill(meta, body, name, source, skillDir));
+        } catch {
+        }
+      }
+    }
+    var BUILTIN_SKILLS = [
+      {
+        name: "review",
+        description: "Review uncommitted changes (or a PR/branch diff) for correctness bugs, edge cases, and security issues. Use when the user asks to review a diff, check their changes before committing, or audit a PR.",
+        source: "builtin",
+        disableModelInvocation: false,
+        userInvocable: true,
+        body: [
+          "Review the following diff like a meticulous senior engineer. Target: $ARGUMENTS",
+          "(If no target given, review the uncommitted working-tree changes below. If a branch or PR",
+          "number is given, run the appropriate `git diff <base>...` or `gh pr diff <n>` yourself first.)",
+          "",
+          "Branch: !`git branch --show-current`",
+          "Status: !`git status --short`",
+          "",
+          "Diff (uncommitted):",
+          "```diff",
+          "!`git diff HEAD --unified=5 --no-color | head -4000`",
+          "```",
+          "",
+          "Review methodology:",
+          "1. Read the surrounding code of every changed hunk (read_file with offset/limit) \u2014 never judge a hunk in isolation.",
+          "2. Look for: correctness bugs, edge cases (empty/null/unicode/concurrency), security issues",
+          "   (injection, path traversal, secrets), breaking API changes (find_references / search callers),",
+          "   silent behaviour changes, and missing error handling.",
+          "3. Check tests: do existing tests cover the change? Are assertions weakened?",
+          "",
+          "Output format:",
+          "- \u{1F534} Critical (must fix before merge) \u2014 with file:line and a concrete fix",
+          "- \u{1F7E1} Warning (should fix) \u2014 with file:line",
+          "- \u{1F7E2} Suggestion (nice to have)",
+          "- Verdict: APPROVE / REQUEST CHANGES with a one-paragraph summary.",
+          "Do NOT modify any files \u2014 this is a read-only review."
+        ].join("\n")
+      }
+    ];
+    function loadSkills2(workDir) {
+      const out = /* @__PURE__ */ new Map();
+      loadFlatCommandDir(path5.join(workDir, ".nexrall", "commands"), "project", out);
+      loadSkillDir(path5.join(workDir, ".nexrall", "skills"), "project", out);
+      loadFlatCommandDir(path5.join(os5.homedir(), ".nexrall", "commands"), "global", out);
+      loadSkillDir(path5.join(os5.homedir(), ".nexrall", "skills"), "global", out);
+      for (const dir of (0, index_1.pluginAssetDirs)(workDir, "commands"))
+        loadFlatCommandDir(dir, "plugin", out);
+      for (const dir of (0, index_1.pluginAssetDirs)(workDir, "skills"))
+        loadSkillDir(dir, "plugin", out);
+      for (const skill of BUILTIN_SKILLS) {
+        if (!out.has(skill.name))
+          out.set(skill.name, skill);
+      }
+      return [...out.values()];
+    }
+    function findSkill2(skills, name) {
+      const want = name.replace(/^\//, "").trim().toLowerCase();
+      return skills.find((s2) => s2.name === want);
+    }
+    function autoInvokableSkills(skills) {
+      return skills.filter((s2) => !s2.disableModelInvocation);
+    }
+    function userInvokableSkills2(skills) {
+      return skills.filter((s2) => s2.userInvocable);
+    }
+    function summariseSkills(skills) {
+      const list = autoInvokableSkills(skills);
+      if (!list.length)
+        return "";
+      return list.map((s2) => `- ${s2.name}: ${s2.description}`).join("\n");
+    }
+    function expandSkill2(skill, argString, workDir) {
+      const expanded = (0, loader_1.expandBody)(skill.body, argString, workDir);
+      if (!skill.dir)
+        return expanded;
+      let siblings = [];
+      try {
+        siblings = fs6.readdirSync(skill.dir).filter((f3) => f3 !== "SKILL.md");
+      } catch {
+      }
+      if (!siblings.length)
+        return expanded;
+      return `[Skill "${skill.name}" \u2014 supporting files available in ${skill.dir} (use read_file with an absolute path to load any of these only if the instructions below need them): ${siblings.join(", ")}]
+
+${expanded}`;
+    }
+  }
+});
+
+// ../core/dist/agent/testIntegrity.js
+var require_testIntegrity = __commonJS({
+  "../core/dist/agent/testIntegrity.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isTestFile = isTestFile;
+    exports2.analyzeTestEdit = analyzeTestEdit;
+    exports2.analyzeWriteToolForTestIntegrity = analyzeWriteToolForTestIntegrity;
+    exports2.encodeTestIntegrityMarker = encodeTestIntegrityMarker;
+    exports2.decodeTestIntegrityMarker = decodeTestIntegrityMarker;
+    exports2.stripTestIntegrityMarker = stripTestIntegrityMarker;
+    var TEST_PATH_RE = /(?:^|[\/\\])(?:tests?|spec|__tests__|testing)[\/\\]|(?:\.|_|-)(?:test|spec|tests)\.[a-z]+$|(?:^|[\/\\])test_[^\/\\]+\.py$|(?:^|[\/\\])[^\/\\]+_test\.(?:go|py|rb)$|Test[^\/\\]*\.(?:java|kt|cs)$|(?:^|[\/\\])[^\/\\]*Tests?\.(?:java|kt|cs)$/i;
+    function isTestFile(path5) {
+      if (!path5 || typeof path5 !== "string")
+        return false;
+      return TEST_PATH_RE.test(path5);
+    }
+    var ASSERTION_RES = [
+      /\bexpect\s*\(/g,
+      // jest / chai / vitest / jasmine
+      /\bassert(?:Equals?|True|False|That|Null|NotNull|Same)?\b/g,
+      // junit / python unittest / generic
+      /\bassert\s*[.(]/g,
+      // node:assert (assert.equal / assert( ) )
+      /\.should\b/g,
+      // chai should / rspec should
+      /\bshould\s*[.(]/g,
+      /\bEXPECT_[A-Z]+\s*\(/g,
+      // gtest
+      /\bASSERT_[A-Z]+\s*\(/g,
+      // gtest
+      /\brequire\.\w+\s*\(/g,
+      // testify require
+      /\bassert\.\w+\s*\(/g,
+      // testify assert
+      /\bt\.(?:Error|Fatal|Errorf|Fatalf)\b/g,
+      // go testing
+      /\bassert!\s*\(|\bassert_eq!\s*\(|\bassert_ne!\s*\(/g
+      // rust
+    ];
+    var TESTCASE_RES = [
+      /\b(?:it|test)\s*\(/g,
+      // jest / mocha / jasmine
+      /\bdef\s+test_\w+/g,
+      // python
+      /\bfunc\s+Test\w+/g,
+      // go
+      /@Test\b/g,
+      // junit
+      /\bfn\s+\w*test\w*\s*\(/gi
+      // rust (best-effort)
+    ];
+    var SKIP_RES = [
+      /\b(?:it|test|describe|context|suite)\s*\.\s*(?:skip|only)\b/g,
+      /\bx(?:it|describe|test|context)\s*\(/g,
+      // xit / xdescribe
+      /\bf(?:it|describe)\s*\(/g,
+      // fit / fdescribe (focus)
+      /@pytest\.mark\.skip\b|@pytest\.mark\.skipif\b|@unittest\.skip\b|@skip\b/g,
+      /\bpytest\.skip\s*\(/g,
+      /\bt\.Skip\s*\(|\bt\.SkipNow\s*\(/g,
+      // go
+      /@Disabled\b|@Ignore\b/g,
+      // junit / kotlin
+      /\.only\s*\(/g
+      // test.only leaks CI coverage
+    ];
+    var TAUTOLOGY_RES = [
+      /\bassert\s+True\b|\bassert\s+1\b|\bassert\s+not\s+False\b/g,
+      // python
+      /\bassert\s*\(\s*true\s*\)|\bassert\.ok\s*\(\s*true\s*\)/gi,
+      // node
+      /\bexpect\s*\(\s*true\s*\)\s*\.\s*to(?:Be|Equal|BeTruthy)\s*\(\s*true\s*\)?/gi,
+      // jest
+      /\bexpect\s*\(\s*(\w+)\s*\)\s*\.\s*toBe\s*\(\s*\1\s*\)/g,
+      // expect(x).toBe(x)
+      /\bassert_eq!\s*\(\s*true\s*,\s*true\s*\)/g,
+      // rust
+      /\bassert!\s*\(\s*true\s*\)/g
+    ];
+    function countMatches(res, text) {
+      let n = 0;
+      for (const re of res) {
+        re.lastIndex = 0;
+        const m2 = text.match(re);
+        if (m2)
+          n += m2.length;
+      }
+      return n;
+    }
+    function countCommentedOutTestLines(oldText, newText) {
+      const oldLines = new Set(oldText.split("\n").map((l) => l.trim()));
+      let n = 0;
+      for (const raw of newText.split("\n")) {
+        const line = raw.trim();
+        const isComment = /^(?:\/\/|#|\/\*|\*)/.test(line);
+        if (!isComment)
+          continue;
+        const body = line.replace(/^(?:\/\/+|#+|\/\*+|\*+)\s?/, "");
+        const looksLikeTest = /\b(expect|assert|it\(|test\(|def test_|func Test|EXPECT_|ASSERT_)\b/.test(body);
+        if (looksLikeTest && oldLines.has(body))
+          n += 1;
+      }
+      return n;
+    }
+    function analyzeTestEdit(path5, oldText, newText) {
+      if (!isTestFile(path5)) {
+        return { isTestFile: false, suspicious: false, findings: [] };
+      }
+      const findings = [];
+      const skipsBefore = countMatches(SKIP_RES, oldText);
+      const skipsAfter = countMatches(SKIP_RES, newText);
+      if (skipsAfter > skipsBefore) {
+        findings.push({
+          kind: "skip-added",
+          reason: `added ${skipsAfter - skipsBefore} skip/only/disabled marker(s) \u2014 tests are being skipped, not fixed`
+        });
       }
       const tautoBefore = countMatches(TAUTOLOGY_RES, oldText);
       const tautoAfter = countMatches(TAUTOLOGY_RES, newText);
@@ -11259,6 +12349,8 @@ var require_executor = __commonJS({
     var sandbox_1 = require_sandbox();
     var auth_1 = require_auth();
     var editCompleteness_1 = require_editCompleteness();
+    var memory_1 = require_memory();
+    var skills_1 = require_skills();
     var testIntegrity_1 = require_testIntegrity();
     var crossFile_1 = require_crossFile();
     var client_1 = require_client();
@@ -11268,6 +12360,10 @@ var require_executor = __commonJS({
     var MAX_FETCH_BYTES = 200 * 1024;
     var MAX_READ_BYTES = 500 * 1024;
     var MAX_OUTPUT_CHARS = 1e5;
+    var MAX_READ_LINES = 2e3;
+    var MAX_READ_TOKENS = 25e3;
+    var READ_CHARS_PER_TOKEN = 4;
+    var MAX_READ_CHARS = MAX_READ_TOKENS * READ_CHARS_PER_TOKEN;
     var MAX_SPILL_BYTES = 20 * 1024 * 1024;
     var SPILL_DIR = path5.join(os5.tmpdir(), "nexrall-code", "bash-output");
     var BLOCKED_REGEXES = [
@@ -11362,24 +12458,50 @@ var require_executor = __commonJS({
         return false;
       }
     }
-    async function readLargeFileWindow(resolved, offset, limit, kb) {
+    function formatNumberedLine(offset, indexInKept, line) {
+      return `${String(offset + indexInKept + 1).padStart(4, " ")}	${line}`;
+    }
+    async function readFileWindowed(resolved, offset, requestedLimit) {
       return new Promise((resolve3) => {
-        const endLine = offset + limit;
+        const explicitLimit = requestedLimit > 0;
+        const lineScanCap = explicitLimit ? Math.min(requestedLimit, MAX_READ_LINES) : MAX_READ_LINES;
+        const hardEndLine = offset + lineScanCap;
         const kept = [];
+        let keptChars = 0;
         let lineNo = 0;
         let carry = "";
         let stopped = false;
+        let hitTokenCap = false;
+        let sawEof = false;
         const stream = fs6.createReadStream(resolved, { encoding: "utf-8", highWaterMark: 256 * 1024 });
+        const tryPushLine = (line) => {
+          const formatted = formatNumberedLine(offset, kept.length, line);
+          const added = formatted.length + 1;
+          if (keptChars + added > MAX_READ_CHARS) {
+            hitTokenCap = true;
+            return false;
+          }
+          kept.push(line);
+          keptChars += added;
+          return true;
+        };
         const finish = () => {
           if (stopped)
             return;
           stopped = true;
           stream.destroy();
+          if (hitTokenCap && explicitLimit) {
+            resolve3({
+              error: `Requested range (offset:${offset}, limit:${requestedLimit}) is too large \u2014 exceeds ${MAX_READ_TOKENS} tokens. Pass a smaller limit, or use search_files to locate the relevant part first.`
+            });
+            return;
+          }
           const first = offset + 1;
           const last = offset + kept.length;
-          const numbered = kept.map((l, i2) => `${String(offset + i2 + 1).padStart(4, " ")}	${l}`).join("\n");
-          const note = kept.length < limit ? ` (reached end of file at line ${last})` : ` (more lines follow \u2014 increase offset to continue)`;
-          resolve3({ output: `[File: ${resolved} \u2014 ${kb} KB, showing lines ${first}-${last}${note}]
+          const numbered = kept.map((l, i2) => formatNumberedLine(offset, i2, l)).join("\n");
+          const totalNote = sawEof ? `/${lineNo}` : "";
+          const note = sawEof ? ` (reached end of file at line ${last})` : ` (more lines follow \u2014 pass offset:${last} to continue, or search_files to locate the relevant part)`;
+          resolve3({ output: `[File: ${resolved} \u2014 lines ${first}-${last}${totalNote}${note}]
 ${numbered}` });
         };
         stream.on("data", (chunk) => {
@@ -11387,18 +12509,30 @@ ${numbered}` });
           const lines = text.split("\n");
           carry = lines.pop() ?? "";
           for (const line of lines) {
-            if (lineNo >= offset && lineNo < endLine)
-              kept.push(line);
+            if (lineNo >= offset) {
+              if (lineNo >= hardEndLine) {
+                finish();
+                return;
+              }
+              if (!tryPushLine(line)) {
+                finish();
+                return;
+              }
+            }
             lineNo++;
-            if (lineNo >= endLine) {
+          }
+        });
+        stream.on("end", () => {
+          if (stopped)
+            return;
+          if (carry !== "" && lineNo >= offset && lineNo < hardEndLine) {
+            if (!tryPushLine(carry)) {
               finish();
               return;
             }
+            lineNo++;
           }
-        });
-        stream.on("end", () => {
-          if (!stopped && carry !== "" && lineNo >= offset && lineNo < endLine)
-            kept.push(carry);
+          sawEof = true;
           finish();
         });
         stream.on("error", (err) => {
@@ -11417,31 +12551,12 @@ ${numbered}` });
         return { error: "Missing required parameter: path" };
       try {
         const resolved = resolvePath(filePath, workDir);
-        const stat2 = fs6.statSync(resolved);
+        fs6.statSync(resolved);
         if (isBinaryFile(resolved)) {
           const ext = path5.extname(resolved).toLowerCase();
           return { error: `Cannot read binary file: ${resolved} (${ext || "no extension"}). Use a text-based tool or convert it first.` };
         }
-        if (stat2.size > MAX_READ_BYTES) {
-          const kb = (stat2.size / 1024).toFixed(0);
-          if (limit <= 0) {
-            return { error: `File too large (${kb} KB, max ${MAX_READ_BYTES / 1024} KB). Pass offset + limit to read a section (e.g. {offset:0, limit:500}), or search_files to locate the relevant part first.` };
-          }
-          return await readLargeFileWindow(resolved, offset, limit, kb);
-        }
-        const content = fs6.readFileSync(resolved, "utf-8");
-        const allLines = content.split("\n");
-        const totalLines = allLines.length;
-        const startLine = offset;
-        const endLine = limit > 0 ? Math.min(startLine + limit, totalLines) : totalLines;
-        const slice = allLines.slice(startLine, endLine);
-        const numbered = slice.map((l, i2) => {
-          const lineNo = String(startLine + i2 + 1).padStart(4, " ");
-          return `${lineNo}	${l}`;
-        }).join("\n");
-        const rangeNote = offset > 0 || limit > 0 ? ` lines ${startLine + 1}-${endLine}/${totalLines}` : ` ${totalLines} lines`;
-        return { output: `[File: ${resolved} (${rangeNote})]
-${numbered}` };
+        return await readFileWindowed(resolved, offset, limit);
       } catch (err) {
         return { error: err.message };
       }
@@ -11977,7 +13092,9 @@ Update these call-sites (or restore the symbol), then run a build/typecheck to c
           walkDir(resolved, (filePath) => {
             const name = path5.basename(filePath);
             const nameLower = name.toLowerCase();
-            if (nameLower.includes(patternLower) || matchesGlob(name, pattern) || matchesPattern(name, pattern)) {
+            const rel = path5.relative(resolved, filePath).replace(/\\/g, "/");
+            const relLower = rel.toLowerCase();
+            if (nameLower.includes(patternLower) || matchesGlob(name, pattern) || matchesPattern(name, pattern) || relLower.includes(patternLower) || matchesGlob(rel, pattern) || matchesPattern(rel, pattern)) {
               matches.push(filePath);
             }
           });
@@ -12002,7 +13119,7 @@ Update these call-sites (or restore the symbol), then run a build/typecheck to c
             args.push("-m", "200", "--regexp", pattern, resolved);
             result = (0, child_process_1.spawnSync)("rg", args, spawnOpts);
           } else {
-            const args = ["-rn", "--binary-files=without-match", "--color=never"];
+            const args = ["-rnE", "--binary-files=without-match", "--color=never"];
             if (ignoreCase)
               args.push("-i");
             if (contextLines > 0)
@@ -12031,8 +13148,10 @@ ${globalCapMatches(output)}` : "";
           }
           if (result.status === 1 && !output)
             return { output: "No matches found." };
-          if (result.status !== 0 && result.status !== 1)
-            return { error: stderr || "search failed" };
+          if (result.status !== 0 && result.status !== 1) {
+            const hint = /parenthes|bracket|brace|Unmatched|repetition-operator|invalid regex/i.test(stderr) ? ' \u2014 the pattern has invalid/unbalanced regex syntax. If you meant to match literal parentheses/brackets, escape them (e.g. "\\(", "\\)"), or simplify the pattern.' : "";
+            return { error: (stderr || "search failed").trim() + hint };
+          }
           output = globalCapMatches(output);
           return { output: output || "No matches found." };
         }
@@ -12373,6 +13492,14 @@ ${diff2}${xfile}` };
             return callback(null, address, family);
           });
         };
+        let settled = false;
+        let selfAborted = false;
+        const finish = (result) => {
+          if (settled)
+            return;
+          settled = true;
+          resolve3(result);
+        };
         const req = transport.get(url, {
           timeout: DEFAULT_TIMEOUT_MS,
           lookup: guardedLookup,
@@ -12385,15 +13512,16 @@ ${diff2}${xfile}` };
         }, (res) => {
           const status = res.statusCode ?? 0;
           if ((status === 301 || status === 302 || status === 307 || status === 308) && res.headers.location) {
+            selfAborted = true;
             req.destroy();
             let nextUrl;
             try {
               nextUrl = new URL(res.headers.location, url).href;
             } catch {
-              resolve3({ error: `Invalid redirect location: ${res.headers.location}` });
+              finish({ error: `Invalid redirect location: ${res.headers.location}` });
               return;
             }
-            fetchUrl({ url: nextUrl }, void 0, _redirectCount + 1).then(resolve3);
+            fetchUrl({ url: nextUrl }, void 0, _redirectCount + 1).then(finish);
             return;
           }
           const contentType = res.headers["content-type"] ?? "";
@@ -12401,6 +13529,19 @@ ${diff2}${xfile}` };
           const chunks = [];
           let totalBytes = 0;
           let truncated = false;
+          const emitBody = () => {
+            let body = Buffer.concat(chunks).toString("utf-8");
+            if (isHtml)
+              body = stripHtml(body);
+            const truncNote = truncated ? `
+
+[Truncated at ${MAX_FETCH_BYTES / 1024}KB]` : "";
+            finish({ output: `HTTP ${status}
+
+<untrusted_web_content url="${url}">
+${body}${truncNote}
+</untrusted_web_content>` });
+          };
           res.on("data", (chunk) => {
             if (totalBytes + chunk.length > MAX_FETCH_BYTES) {
               const remaining = MAX_FETCH_BYTES - totalBytes;
@@ -12408,31 +13549,28 @@ ${diff2}${xfile}` };
                 chunks.push(chunk.subarray(0, remaining));
               totalBytes = MAX_FETCH_BYTES;
               truncated = true;
+              selfAborted = true;
               req.destroy();
+              emitBody();
             } else {
               chunks.push(chunk);
               totalBytes += chunk.length;
             }
           });
-          res.on("end", () => {
-            let body = Buffer.concat(chunks).toString("utf-8");
-            if (isHtml)
-              body = stripHtml(body);
-            const truncNote = truncated ? `
-
-[Truncated at ${MAX_FETCH_BYTES / 1024}KB]` : "";
-            resolve3({ output: `HTTP ${status}
-
-<untrusted_web_content url="${url}">
-${body}${truncNote}
-</untrusted_web_content>` });
+          res.on("end", emitBody);
+          res.on("error", (err) => {
+            if (!selfAborted)
+              finish({ error: err.message });
           });
-          res.on("error", (err) => resolve3({ error: err.message }));
         });
-        req.on("error", (err) => resolve3({ error: err.message }));
+        req.on("error", (err) => {
+          if (!selfAborted)
+            finish({ error: err.message });
+        });
         req.on("timeout", () => {
+          selfAborted = true;
           req.destroy();
-          resolve3({ error: `Request timed out after ${DEFAULT_TIMEOUT_MS}ms` });
+          finish({ error: `Request timed out after ${DEFAULT_TIMEOUT_MS}ms` });
         });
       });
     }
@@ -12860,36 +13998,48 @@ ${lines.join("\n")}`;
       return { output: `Found ${photos.length} photo(s) for "${query}":
 ${lines.join("\n")}` };
     }
-    var MEMORY_FILE = path5.join(os5.homedir(), ".nexrall", "memory.md");
-    async function memoryWrite(input) {
+    function memoryScopeOf(input) {
+      return input.scope === "global" ? "global" : "project";
+    }
+    async function memoryWrite(input, workDir) {
       const content = typeof input.content === "string" ? input.content.trim() : "";
       if (!content)
         return { error: "content is required" };
-      const dir = path5.dirname(MEMORY_FILE);
-      fs6.mkdirSync(dir, { recursive: true });
-      if (fs6.existsSync(MEMORY_FILE)) {
-        const existing = fs6.readFileSync(MEMORY_FILE, "utf-8").toLowerCase();
-        const fingerprint = content.toLowerCase().slice(0, 60);
-        if (existing.includes(fingerprint)) {
-          return { output: `Memory already recorded (skipped duplicate): ${content}` };
-        }
-      }
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      const entry = `
-- [${timestamp}] ${content}`;
-      fs6.appendFileSync(MEMORY_FILE, entry, "utf-8");
-      return { output: `Memory saved: ${content}` };
-    }
-    async function memoryRead(_input) {
+      const scope = memoryScopeOf(input);
+      const r2 = await (0, memory_1.writeMemory)(content, scope, workDir);
+      if (!r2.ok)
+        return { error: "failed to save memory" };
+      return { output: r2.already ? `Memory already recorded (skipped duplicate): ${content}` : `Memory saved (${scope}): ${content}` };
+    }
+    async function memoryRead(input, workDir) {
       try {
-        if (!fs6.existsSync(MEMORY_FILE))
-          return { output: "No memories saved yet." };
-        const content = fs6.readFileSync(MEMORY_FILE, "utf-8").trim();
-        return { output: content || "No memories saved yet." };
+        if (input && (input.scope === "project" || input.scope === "global")) {
+          const mem2 = (0, memory_1.readMemory)(input.scope, workDir);
+          return { output: mem2 || "No memories saved yet." };
+        }
+        const mem = (0, memory_1.readAllMemory)(workDir);
+        return { output: mem || "No memories saved yet." };
       } catch (err) {
         return { error: err.message };
       }
     }
+    async function useSkill(input, workDir) {
+      const name = typeof input.name === "string" ? input.name.trim() : "";
+      if (!name)
+        return { error: "name is required (the skill to invoke)" };
+      const dir = workDir ?? process.cwd();
+      const skills = (0, skills_1.loadSkills)(dir);
+      const skill = (0, skills_1.findSkill)(skills, name);
+      if (!skill) {
+        const known = skills.map((s2) => s2.name).join(", ") || "(none defined)";
+        return { error: `Unknown skill "${name}". Available: ${known}.` };
+      }
+      const args = typeof input.args === "string" ? input.args : "";
+      const expanded = (0, skills_1.expandSkill)(skill, args, dir);
+      return { output: `[Skill "${skill.name}" loaded \u2014 follow these instructions:]
+
+${expanded}` };
+    }
     function semanticPreamble(input, workDir) {
       const p = typeof input.path === "string" ? input.path : "";
       const line = typeof input.line === "number" ? Math.floor(input.line) : 0;
@@ -12951,6 +14101,7 @@ ${lines.join("\n")}` };
       notebook_edit: notebookEdit,
       memory_write: memoryWrite,
       memory_read: memoryRead,
+      use_skill: useSkill,
       bash_output: bashOutput,
       kill_shell: killShell,
       // LSP-lite fallback (regex-based). In VS Code these names are intercepted by
@@ -12983,7 +14134,10 @@ ${lines.join("\n")}` };
       "get_workspace_symbols",
       "go_to_definition",
       "find_references",
-      "get_hover"
+      "get_hover",
+      "memory_write",
+      "memory_read",
+      "use_skill"
     ]);
     async function executeTool(name, input, abortSignal, sandbox, workDir, agentScope) {
       if (!TOOL_MAP[name])
@@ -13006,150 +14160,6 @@ ${lines.join("\n")}` };
   }
 });
 
-// ../core/dist/plugins/index.js
-var require_plugins = __commonJS({
-  "../core/dist/plugins/index.js"(exports2) {
-    "use strict";
-    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m2, k, k2) {
-      if (k2 === void 0)
-        k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m2, k);
-      if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m2[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc);
-    } : function(o, m2, k, k2) {
-      if (k2 === void 0)
-        k2 = k;
-      o[k2] = m2[k];
-    });
-    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
-      Object.defineProperty(o, "default", { enumerable: true, value: v });
-    } : function(o, v) {
-      o["default"] = v;
-    });
-    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() {
-      var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function(o2) {
-          var ar = [];
-          for (var k in o2)
-            if (Object.prototype.hasOwnProperty.call(o2, k))
-              ar[ar.length] = k;
-          return ar;
-        };
-        return ownKeys(o);
-      };
-      return function(mod) {
-        if (mod && mod.__esModule)
-          return mod;
-        var result = {};
-        if (mod != null) {
-          for (var k = ownKeys(mod), i2 = 0; i2 < k.length; i2++)
-            if (k[i2] !== "default")
-              __createBinding(result, mod, k[i2]);
-        }
-        __setModuleDefault(result, mod);
-        return result;
-      };
-    }();
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.loadPlugins = loadPlugins3;
-    exports2.pluginAssetDirs = pluginAssetDirs;
-    exports2.pluginHooks = pluginHooks;
-    exports2.pluginMcpServers = pluginMcpServers;
-    var fs6 = __importStar(require("fs"));
-    var path5 = __importStar(require("path"));
-    var os5 = __importStar(require("os"));
-    function readMeta(dir) {
-      try {
-        const raw = fs6.readFileSync(path5.join(dir, "plugin.json"), "utf-8");
-        const j = JSON.parse(raw);
-        return {
-          name: typeof j.name === "string" ? j.name : void 0,
-          version: typeof j.version === "string" ? j.version : void 0,
-          description: typeof j.description === "string" ? j.description : void 0
-        };
-      } catch {
-        return {};
-      }
-    }
-    function scanRoot(root, scope, into) {
-      let entries;
-      try {
-        entries = fs6.readdirSync(root, { withFileTypes: true });
-      } catch {
-        return;
-      }
-      for (const entry of entries) {
-        if (!entry.isDirectory() && !entry.isSymbolicLink())
-          continue;
-        const dir = path5.join(root, entry.name);
-        try {
-          if (!fs6.statSync(dir).isDirectory())
-            continue;
-        } catch {
-          continue;
-        }
-        const meta = readMeta(dir);
-        const name = meta.name || entry.name;
-        if (into.has(name))
-          continue;
-        into.set(name, { name, version: meta.version, description: meta.description, dir, scope });
-      }
-    }
-    function loadPlugins3(workDir) {
-      const out = /* @__PURE__ */ new Map();
-      scanRoot(path5.join(workDir, ".nexrall", "plugins"), "project", out);
-      scanRoot(path5.join(os5.homedir(), ".nexrall", "plugins"), "global", out);
-      return [...out.values()];
-    }
-    function pluginAssetDirs(workDir, kind) {
-      return loadPlugins3(workDir).map((p) => path5.join(p.dir, kind)).filter((d) => {
-        try {
-          return fs6.statSync(d).isDirectory();
-        } catch {
-          return false;
-        }
-      });
-    }
-    function pluginHooks(workDir) {
-      const merged = {};
-      for (const p of loadPlugins3(workDir)) {
-        try {
-          const raw = fs6.readFileSync(path5.join(p.dir, "hooks.json"), "utf-8");
-          const j = JSON.parse(raw);
-          const hooks = j.hooks ?? j;
-          for (const [phase, entries] of Object.entries(hooks)) {
-            if (!Array.isArray(entries))
-              continue;
-            merged[phase] = [...merged[phase] ?? [], ...entries];
-          }
-        } catch {
-        }
-      }
-      return merged;
-    }
-    function pluginMcpServers(workDir) {
-      const merged = {};
-      for (const p of loadPlugins3(workDir)) {
-        try {
-          const raw = fs6.readFileSync(path5.join(p.dir, "mcp.json"), "utf-8");
-          const j = JSON.parse(raw);
-          const servers = j.mcpServers ?? j;
-          for (const [name, cfg] of Object.entries(servers)) {
-            if (!(name in merged))
-              merged[name] = cfg;
-          }
-        } catch {
-        }
-      }
-      return merged;
-    }
-  }
-});
-
 // ../core/dist/agent/agentTypes.js
 var require_agentTypes = __commonJS({
   "../core/dist/agent/agentTypes.js"(exports2) {
@@ -13706,16 +14716,22 @@ var require_loop = __commonJS({
     exports2.ledgerRecord = ledgerRecord;
     exports2.ledgerSummary = ledgerSummary;
     exports2.pruneOldToolResults = pruneOldToolResults;
+    exports2.estimateTokensRough = estimateTokensRough;
+    exports2.compactMessagesForResume = compactMessagesForResume2;
     exports2.runAgentLoop = runAgentLoop2;
+    exports2.trimToResumableBoundary = trimToResumableBoundary;
+    var types_1 = require_types();
     var client_1 = require_client();
     var executor_1 = require_executor();
     var agentTypes_1 = require_agentTypes();
+    var skills_1 = require_skills();
     var rules_1 = require_rules();
     var sandbox_1 = require_sandbox();
     var index_1 = require_plugins();
     var testIntegrity_1 = require_testIntegrity();
     var flaky_1 = require_flaky();
     var claimEvidence_1 = require_claimEvidence();
+    var memory_1 = require_memory();
     var fs6 = __importStar(require("fs"));
     var path5 = __importStar(require("path"));
     var child_process_1 = require("child_process");
@@ -13914,6 +14930,8 @@ var require_loop = __commonJS({
           const preview = typeof input.prompt === "string" ? input.prompt.slice(0, 60) : "";
           return `Sub-task: ${desc || preview}${!desc && preview.length === 60 ? "\u2026" : ""}`;
         }
+        case "use_skill":
+          return `Use skill: /${input.name ?? "(unknown)"}`;
         case "get_diagnostics":
           return input.path ? `Get diagnostics: ${input.path}` : "Get workspace diagnostics";
         case "go_to_definition":
@@ -13977,6 +14995,22 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
           onText: () => {
           },
           // sub-agent text is returned as the tool result, not streamed live
+          // Forwarded DELIBERATELY, and it must be a real handler rather than a no-op.
+          //
+          // A sub-agent streams no text (onText above is a no-op) but it DOES stream thinking
+          // through the parent's UI (see onThinking/onThinkingDelta below), and thinking sets
+          // `emittedToCaller`. So a sub-agent stream that dies after reasoning genuinely has
+          // rendered output to discard — a no-op here would let the restart proceed and then
+          // re-stream that reasoning on top of the copy still on screen, the exact duplication
+          // the opt-in exists to prevent.
+          //
+          // Forwarding is safe because the parent's own output is already closed by this
+          // point: dispatching the `task` tool goes through options.onToolUse, which finalizes
+          // the parent's bubble (VS Code) / flushes the renderer (CLI) before the sub-agent
+          // starts. The only live, discardable element at restart time is the sub-agent's own
+          // thinking block. Completed tool rows are left alone — those are real side effects
+          // that actually happened.
+          onStreamRestart: (reason, chars) => options.onStreamRestart?.(reason, chars),
           // Forward tool events with isSubTask=true so the UI can render a badge
           // instead of prepending "[sub-task]" to the tool name (which caused double-prefix
           // when the name was already labelled, and mixed display concerns into the data layer).
@@ -14009,7 +15043,13 @@ ${tail}`;
       pro: 1e6,
       ultra: 1e6
     };
-    var AUTO_COMPACT_THRESHOLD = 0.8;
+    function envFraction(name, fallback) {
+      const v = Number(process.env[name]);
+      return Number.isFinite(v) && v > 0 && v < 1 ? v : fallback;
+    }
+    var AUTO_PRUNE_THRESHOLD = envFraction("NEXRALL_PRUNE_THRESHOLD", 0.35);
+    var AUTO_COMPACT_THRESHOLD = envFraction("NEXRALL_COMPACT_THRESHOLD", 0.8);
+    var PRUNE_MIN_RECLAIM_BYTES = 256 * 1024;
     var COMPACT_KEEP_MIN = 6;
     var MAX_BODY_BYTES = 8 * 1024 * 1024;
     function estimateBodyBytes(messages) {
@@ -14160,11 +15200,12 @@ ${tail}`;
     var PRUNE_STUB_KEEP_CHARS = 400;
     var PRUNE_MARKER = "\n\n[\u2026 ";
     var PRUNE_MARKER_TAIL = " pruned to conserve context. Re-run the tool if you need the full result.]";
-    function pruneOldToolResults(messages) {
+    function pruneOldToolResults(messages, minReclaimBytes = 0) {
       const cutoff = messages.length - PRUNE_KEEP_RECENT;
       if (cutoff <= 1)
         return 0;
-      let reclaimed = 0;
+      const targets = [];
+      let total = 0;
       for (let i2 = 0; i2 < cutoff; i2++) {
         const m2 = messages[i2];
         if (!Array.isArray(m2.content))
@@ -14179,10 +15220,17 @@ ${tail}`;
             continue;
           const head = text.slice(0, PRUNE_STUB_KEEP_CHARS);
           const omitted = text.length - head.length;
-          b.content = `${head}${PRUNE_MARKER}${omitted} chars of earlier tool output${PRUNE_MARKER_TAIL}`;
-          reclaimed += omitted;
+          targets.push({ block: b, head, omitted });
+          total += omitted;
         }
       }
+      if (total < minReclaimBytes)
+        return 0;
+      let reclaimed = 0;
+      for (const { block, head, omitted } of targets) {
+        block.content = `${head}${PRUNE_MARKER}${omitted} chars of earlier tool output${PRUNE_MARKER_TAIL}`;
+        reclaimed += omitted;
+      }
       return reclaimed;
     }
     function originalTaskText(messages) {
@@ -14204,12 +15252,24 @@ ${tail}`;
       let summary = "";
       try {
         const reply = await (0, client_1.streamChat)([{ role: "user", content: [{ type: "text", text: summaryPrompt }] }], {
-          model: options.model ?? "turbo",
+          // COST: the summariser is a mechanical "bullet-point this transcript" task —
+          // its quality is indistinguishable across model tiers, so there is no reason
+          // to run it on the user's (possibly expensive) tier. Force 'turbo' (Sonnet 5):
+          // it is the cheapest 1M-context tier (in $2.0/1M vs Opus $2.5, Fable $3.0;
+          // out $15/1M vs $25 / $50), so this is always ≤ the user's cost, and its 1M
+          // window comfortably holds the transcript (capped at ~170K tokens by
+          // transcriptOf) even on the largest sessions.
+          model: "turbo",
           mode: "ask",
           // summariser must not call tools; ask-mode discourages action
           env: options.env,
           clientType: options.clientType,
-          abortSignal: options.abortSignal
+          abortSignal: options.abortSignal,
+          // The summariser renders NOTHING (onEvent below is a no-op) and its result is
+          // read only from the returned message, so a restart has nothing to roll back —
+          // always safe. Worth enabling: a blip here used to abandon compaction entirely,
+          // which then let the very next turn hit the context wall it was meant to prevent.
+          allowRestartAfterRender: true
         }, () => {
         });
         summary = reply.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join("").trim();
@@ -14235,6 +15295,88 @@ ${summary}
 Continue the work from here.` }] });
       return true;
     }
+    async function maybeCompactMemory(scope, options) {
+      try {
+        await (0, memory_1.compactMemoryIfNeeded)(scope, options.workDir, async (prompt2) => {
+          const reply = await (0, client_1.streamChat)([{ role: "user", content: [{ type: "text", text: prompt2 }] }], {
+            // Same reasoning as autoCompactMessages' summariser: a mechanical
+            // consolidation task, always run on the cheapest 1M-context tier
+            // regardless of the user's chosen model for the actual conversation.
+            model: "turbo",
+            mode: "ask",
+            env: options.env,
+            clientType: options.clientType,
+            abortSignal: options.abortSignal,
+            // Same as the transcript summariser: no rendered output, result read only from
+            // the returned message, so restarting on a blip is always safe.
+            allowRestartAfterRender: true
+          }, () => {
+          });
+          return reply.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
+        });
+      } catch {
+      }
+    }
+    var RESUME_CHARS_PER_TOKEN = 4;
+    function estimateTokensRough(messages) {
+      return Math.ceil(estimateBodyBytes(messages) / RESUME_CHARS_PER_TOKEN);
+    }
+    async function compactMessagesForResume2(messages, opts) {
+      if (messages.length <= COMPACT_KEEP_MIN + 2)
+        return false;
+      const settings = (0, rules_1.loadSettings)(opts.workDir);
+      if (!resolveAutoCompact(void 0, settings.raw))
+        return false;
+      const contextWindow = MODEL_CONTEXT_TOKENS[opts.model ?? "turbo"] ?? 1e6;
+      let bodyBytes = estimateBodyBytes(messages);
+      let tokenGuess = estimateTokensRough(messages);
+      const overPruneThreshold = () => tokenGuess > contextWindow * AUTO_PRUNE_THRESHOLD || bodyBytes > MAX_BODY_BYTES;
+      const overCompactThreshold = () => tokenGuess > contextWindow * AUTO_COMPACT_THRESHOLD || bodyBytes > MAX_BODY_BYTES;
+      if (!overPruneThreshold())
+        return false;
+      let compacted = false;
+      if (messages.length > PRUNE_KEEP_RECENT + 2) {
+        const reclaimed = pruneOldToolResults(messages, PRUNE_MIN_RECLAIM_BYTES);
+        if (reclaimed > 0) {
+          bodyBytes = estimateBodyBytes(messages);
+          tokenGuess = estimateTokensRough(messages);
+          compacted = true;
+          opts.onNotice?.(`
+\u267B\uFE0F Trimmed ~${(reclaimed / (1024 * 1024)).toFixed(1)}MB of older tool output before resuming this chat.
+`);
+        }
+      }
+      let guard = 0;
+      while (overCompactThreshold() && messages.length > COMPACT_KEEP_MIN + 2 && guard < 5) {
+        guard += 1;
+        const did = await autoCompactMessages(messages, {
+          workDir: opts.workDir,
+          model: opts.model,
+          clientType: opts.clientType,
+          env: opts.env,
+          onText: () => {
+          },
+          onToolUse: () => {
+          },
+          onToolResult: () => {
+          },
+          onUsage: () => {
+          },
+          requestPermission: async () => false
+        });
+        if (!did)
+          break;
+        compacted = true;
+        bodyBytes = estimateBodyBytes(messages);
+        tokenGuess = estimateTokensRough(messages);
+      }
+      if (compacted) {
+        opts.onNotice?.(`
+\u267B\uFE0F Auto-compacted this chat's earlier history before resuming, to avoid resending it at full cost.
+`);
+      }
+      return compacted;
+    }
     async function runAgentLoop2(initialMessages, options) {
       const messages = [...initialMessages];
       const model = options.model ?? "turbo";
@@ -14243,6 +15385,7 @@ Continue the work from here.` }] });
       const agentScope = options._agentScope ?? "root";
       const agentTypes = (0, agentTypes_1.loadAgentTypes)(options.workDir);
       const agentsCatalogue = depth === 0 ? (0, agentTypes_1.summariseAgents)(agentTypes) : "";
+      const skillsCatalogue = (0, skills_1.summariseSkills)((0, skills_1.loadSkills)(options.workDir));
       const settings = (0, rules_1.loadSettings)(options.workDir);
       const sandboxCfg = (0, sandbox_1.parseSandboxConfig)(settings.raw.sandbox) ?? void 0;
       const maxIterations = resolveMaxIterations(options.maxIterations, settings.raw);
@@ -14254,6 +15397,7 @@ Continue the work from here.` }] });
       let compacting = false;
       const hardCap = autoContinue ? Math.max(maxIterations, MAX_ITERATIONS_CEILING) : maxIterations;
       let completedCleanly = false;
+      let completedRounds = 0;
       let stalledOut = false;
       let consecutiveErrorRounds = 0;
       let budget = maxIterations;
@@ -14270,16 +15414,15 @@ Continue the work from here.` }] });
           if (options.abortSignal?.aborted)
             break;
           let bodyBytes = estimateBodyBytes(messages);
+          const prunePressure = lastPromptTokens > contextWindow * AUTO_PRUNE_THRESHOLD;
           const tokenPressure = lastPromptTokens > contextWindow * AUTO_COMPACT_THRESHOLD;
           let bytePressure = bodyBytes > MAX_BODY_BYTES;
-          if (autoCompact && !compacting && bytePressure && messages.length > PRUNE_KEEP_RECENT + 2) {
-            const reclaimed = pruneOldToolResults(messages);
+          if (autoCompact && !compacting && (prunePressure || bytePressure) && messages.length > PRUNE_KEEP_RECENT + 2) {
+            const reclaimed = pruneOldToolResults(messages, PRUNE_MIN_RECLAIM_BYTES);
             if (reclaimed > 0) {
               bodyBytes = estimateBodyBytes(messages);
               bytePressure = bodyBytes > MAX_BODY_BYTES;
-              options.onText(`
-\u267B\uFE0F Trimmed ~${(reclaimed / (1024 * 1024)).toFixed(1)}MB of older tool output to conserve context.
-`);
+              (options.onNotice ?? options.onText)(`\u267B\uFE0F Trimmed ~${(reclaimed / (1024 * 1024)).toFixed(1)}MB of already-processed tool output to keep this chat cheap to continue.`);
             }
           }
           if (autoCompact && !compacting && (tokenPressure || bytePressure) && messages.length > COMPACT_KEEP_MIN + 2) {
@@ -14289,9 +15432,7 @@ Continue the work from here.` }] });
               if (did) {
                 lastPromptTokens = 0;
                 const reason = bytePressure ? `body ~${(bodyBytes / (1024 * 1024)).toFixed(1)}MB` : "context window";
-                options.onText(`
-\u267B\uFE0F Auto-compacted earlier conversation to stay within the ${reason}.
-`);
+                (options.onNotice ?? options.onText)(`\u267B\uFE0F Auto-compacted earlier conversation to stay within the ${reason}.`);
               }
             } finally {
               compacting = false;
@@ -14302,7 +15443,6 @@ Continue the work from here.` }] });
 \u26A0\uFE0F Approaching the ${budget}-step limit (step ${iteration + 1}). Please wrap up and summarise what has been done.
 `);
           }
-          const pendingToolUse = [];
           const onEvent = (event) => {
             switch (event.type) {
               case "text":
@@ -14318,21 +15458,31 @@ Continue the work from here.` }] });
                 options.onThinkingProgress?.(event.tokens);
                 break;
               case "tool_use":
-                pendingToolUse.push({
-                  type: "tool_use",
-                  id: event.id,
-                  name: event.name,
-                  input: event.input
-                });
                 break;
               case "usage":
-                lastPromptTokens = (event.usage.input_tokens ?? 0) + (event.usage.cache_creation_input_tokens ?? 0) + (event.usage.cache_read_input_tokens ?? 0);
-                options.onUsage(event.usage);
+                if (!event.partial) {
+                  lastPromptTokens = (event.usage.input_tokens ?? 0) + (event.usage.cache_creation_input_tokens ?? 0) + (event.usage.cache_read_input_tokens ?? 0);
+                }
+                options.onUsage(event.usage, event.partial === true || event.replayed === true);
                 break;
               case "message_complete":
                 break;
+              case "retry":
+                options.onRetry?.(event.attempt, event.maxAttempts, event.reason);
+                break;
+              case "retry_resolved":
+                options.onRetryResolved?.();
+                break;
+              case "stream_restart":
+                options.onStreamRestart?.(event.reason, event.discardedChars);
+                break;
+              case "balance_status":
+                options.onBalanceStatus?.(event.balance, event.zero);
+                break;
               case "done":
+                break;
               case "error":
+                options.onNotice?.(`\u26A0\uFE0F ${event.message}`);
                 break;
             }
           };
@@ -14348,13 +15498,25 @@ Continue the work from here.` }] });
               clientType: options.clientType,
               abortSignal: options.abortSignal,
               extraTools: options.mcpManager?.getAnthropicTools(),
-              agents: agentsCatalogue || void 0
+              agents: agentsCatalogue || void 0,
+              skills: skillsCatalogue || void 0,
+              // Only allow a post-render restart when the caller actually implements the
+              // rollback. Without a handler the partial output can't be un-rendered, so we
+              // keep the old conservative behaviour (fail the turn) rather than duplicate
+              // text on screen.
+              allowRestartAfterRender: !!options.onStreamRestart
             }, onEvent);
           } catch (err) {
             if (options.abortSignal?.aborted || err.name === "AbortError")
               break;
+            const status = err.status;
+            if (status === 402) {
+              const balance = err.balance ?? 0;
+              options.onBalanceStatus?.(balance, true);
+              break;
+            }
             runSimpleHooks(hooks.OnError, options.workDir);
-            throw new Error(`Stream failed: ${err.message}`);
+            throw new types_1.AgentTurnError(`Stream failed: ${err.message}`, trimToResumableBoundary(messages), completedRounds, err);
           }
           if (options.abortSignal?.aborted)
             break;
@@ -14371,9 +15533,12 @@ Continue the work from here.` }] });
             completedCleanly = true;
             break;
           }
-          messages.push(assistantMessage);
+          const { stopReason: _stopReason, ...historyMessage } = assistantMessage;
+          messages.push(historyMessage);
           const serverSideResultIds = new Set(assistantMessage.content.filter((b) => b.type === "tool_result").map((b) => b.tool_use_id).filter((id) => !!id));
           const toolUseBlocks = assistantMessage.content.filter((block) => block.type === "tool_use" && !serverSideResultIds.has(block.id));
+          const lastBlock = assistantMessage.content[assistantMessage.content.length - 1];
+          const truncatedToolUseId = assistantMessage.stopReason === "max_tokens" && lastBlock?.type === "tool_use" ? lastBlock.id : void 0;
           if (toolUseBlocks.length === 0) {
             const queued = options.takePendingInput?.() ?? [];
             if (queued.length) {
@@ -14441,8 +15606,15 @@ Continue the work from here.` }] });
           const toolResults = await Promise.all(toolUseBlocks.map(async (block) => {
             const { id, name, input } = block;
             options.onToolUse(name, input);
-            const description = humanDescription(name, input);
             let result;
+            if (id === truncatedToolUseId) {
+              result = {
+                error: `This tool call (${name}) was CUT OFF because the response hit the model's output-token limit mid-generation (stop_reason: max_tokens) \u2014 its arguments may be incomplete or missing fields entirely, so it was NOT executed to avoid a silent partial edit. Retry with a SMALLER call: ` + (name === "multi_edit" || name === "edit_file" ? "split this into fewer edits per call (or call edit_file once per change instead of one large multi_edit), " : name === "write_file" ? "write the file in smaller chunks via write_file + edit_file follow-ups instead of one large write_file, " : "") + `so the full response fits comfortably under the per-turn output budget.`
+              };
+              options.onToolResult(name, result);
+              return { block: { ...block, id }, result };
+            }
+            const description = humanDescription(name, input);
             let permitted;
             try {
               permitted = await options.requestPermission({ tool: name, input, description });
@@ -14479,6 +15651,10 @@ Continue the work from here.` }] });
                 } catch (err) {
                   result = { error: `Tool execution failed: ${err.message}` };
                 }
+                if (name === "memory_write" && result.error === void 0) {
+                  const scope = input.scope === "global" ? "global" : "project";
+                  void maybeCompactMemory(scope, options);
+                }
                 const post = runToolHooks(hooks.PostToolUse, "PostToolUse", name, input, options.workDir, result);
                 const injected = [pre.context, post.context].filter(Boolean).join("\n");
                 if (injected) {
@@ -14540,6 +15716,7 @@ ${result.output}` : `Error: ${result.error}` : result.output ?? "",
             content: toolResultContent
           };
           messages.push(toolResultMessage);
+          completedRounds++;
           options.onProgress?.(messages);
           const allErrored = toolResults.length > 0 && toolResults.every(({ result }) => result.error !== void 0);
           consecutiveErrorRounds = allErrored ? consecutiveErrorRounds + 1 : 0;
@@ -14565,11 +15742,32 @@ ${result.output}` : `Error: ${result.error}` : result.output ?? "",
 `);
           }
         }
+      } catch (err) {
+        if (err instanceof types_1.AgentTurnError)
+          throw err;
+        if (options.abortSignal?.aborted || err.name === "AbortError")
+          throw err;
+        throw new types_1.AgentTurnError(err?.message || "The turn ended unexpectedly", trimToResumableBoundary(messages), completedRounds, err);
       } finally {
         runSimpleHooks(hooks.OnStop, options.workDir);
       }
       return messages;
     }
+    function trimToResumableBoundary(messages) {
+      const isUnansweredInvocation = (m2) => {
+        if (m2?.role !== "assistant" || !Array.isArray(m2.content))
+          return false;
+        const blocks = m2.content;
+        if (blocks.some((b) => b?.type === "tool_use"))
+          return true;
+        const answeredIds = new Set(blocks.filter((b) => /_tool_result$/.test(b?.type ?? "")).map((b) => b?.tool_use_id));
+        return blocks.some((b) => b?.type === "server_tool_use" && !answeredIds.has(b?.id));
+      };
+      let end = messages.length;
+      while (end > 0 && isUnansweredInvocation(messages[end - 1]))
+        end--;
+      return end === messages.length ? messages : messages.slice(0, end);
+    }
   }
 });
 
@@ -15668,193 +16866,6 @@ var require_manager2 = __commonJS({
   }
 });
 
-// ../core/dist/commands/loader.js
-var require_loader = __commonJS({
-  "../core/dist/commands/loader.js"(exports2) {
-    "use strict";
-    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m2, k, k2) {
-      if (k2 === void 0)
-        k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m2, k);
-      if (!desc || ("get" in desc ? !m2.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m2[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc);
-    } : function(o, m2, k, k2) {
-      if (k2 === void 0)
-        k2 = k;
-      o[k2] = m2[k];
-    });
-    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
-      Object.defineProperty(o, "default", { enumerable: true, value: v });
-    } : function(o, v) {
-      o["default"] = v;
-    });
-    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() {
-      var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function(o2) {
-          var ar = [];
-          for (var k in o2)
-            if (Object.prototype.hasOwnProperty.call(o2, k))
-              ar[ar.length] = k;
-          return ar;
-        };
-        return ownKeys(o);
-      };
-      return function(mod) {
-        if (mod && mod.__esModule)
-          return mod;
-        var result = {};
-        if (mod != null) {
-          for (var k = ownKeys(mod), i2 = 0; i2 < k.length; i2++)
-            if (k[i2] !== "default")
-              __createBinding(result, mod, k[i2]);
-        }
-        __setModuleDefault(result, mod);
-        return result;
-      };
-    }();
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.loadSlashCommands = loadSlashCommands2;
-    exports2.findSlashCommand = findSlashCommand2;
-    exports2.expandCommand = expandCommand2;
-    var fs6 = __importStar(require("fs"));
-    var path5 = __importStar(require("path"));
-    var os5 = __importStar(require("os"));
-    var child_process_1 = require("child_process");
-    var index_1 = require_plugins();
-    var BUILTIN_COMMANDS = [
-      {
-        name: "review",
-        description: "Review uncommitted changes (or a PR/branch diff) for bugs and risks",
-        source: "builtin",
-        body: [
-          "Review the following diff like a meticulous senior engineer. Target: $ARGUMENTS",
-          "(If no target given, review the uncommitted working-tree changes below. If a branch or PR",
-          "number is given, run the appropriate `git diff <base>...` or `gh pr diff <n>` yourself first.)",
-          "",
-          "Branch: !`git branch --show-current`",
-          "Status: !`git status --short`",
-          "",
-          "Diff (uncommitted):",
-          "```diff",
-          "!`git diff HEAD --unified=5 --no-color | head -4000`",
-          "```",
-          "",
-          "Review methodology:",
-          "1. Read the surrounding code of every changed hunk (read_file with offset/limit) \u2014 never judge a hunk in isolation.",
-          "2. Look for: correctness bugs, edge cases (empty/null/unicode/concurrency), security issues",
-          "   (injection, path traversal, secrets), breaking API changes (find_references / search callers),",
-          "   silent behaviour changes, and missing error handling.",
-          "3. Check tests: do existing tests cover the change? Are assertions weakened?",
-          "",
-          "Output format:",
-          "- \u{1F534} Critical (must fix before merge) \u2014 with file:line and a concrete fix",
-          "- \u{1F7E1} Warning (should fix) \u2014 with file:line",
-          "- \u{1F7E2} Suggestion (nice to have)",
-          "- Verdict: APPROVE / REQUEST CHANGES with a one-paragraph summary.",
-          "Do NOT modify any files \u2014 this is a read-only review."
-        ].join("\n")
-      }
-    ];
-    function parseFrontmatter(raw) {
-      const m2 = /^\s*---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(raw);
-      if (!m2)
-        return { meta: {}, body: raw.trim() };
-      const meta = {};
-      for (const line of m2[1].split(/\r?\n/)) {
-        const kv = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/.exec(line.trim());
-        if (kv)
-          meta[kv[1].toLowerCase()] = kv[2].trim().replace(/^["']|["']$/g, "");
-      }
-      return { meta, body: (m2[2] ?? "").trim() };
-    }
-    function loadDir(dir, source, into) {
-      let files;
-      try {
-        files = fs6.readdirSync(dir).filter((f3) => f3.endsWith(".md"));
-      } catch {
-        return;
-      }
-      for (const file of files) {
-        try {
-          const raw = fs6.readFileSync(path5.join(dir, file), "utf-8");
-          const { meta, body } = parseFrontmatter(raw);
-          const name = (meta.name || path5.basename(file, ".md")).trim().toLowerCase();
-          if (!name)
-            continue;
-          if (source !== "project" && into.has(name))
-            continue;
-          const model = ["turbo", "pro", "ultra"].find((x2) => x2 === (meta.model ?? "").toLowerCase());
-          into.set(name, {
-            name,
-            description: meta.description || `Custom /${name} command`,
-            model,
-            mode: meta.mode || void 0,
-            body,
-            source
-          });
-        } catch {
-        }
-      }
-    }
-    function loadSlashCommands2(workDir) {
-      const out = /* @__PURE__ */ new Map();
-      loadDir(path5.join(workDir, ".nexrall", "commands"), "project", out);
-      loadDir(path5.join(os5.homedir(), ".nexrall", "commands"), "global", out);
-      for (const dir of (0, index_1.pluginAssetDirs)(workDir, "commands"))
-        loadDir(dir, "plugin", out);
-      for (const cmd of BUILTIN_COMMANDS) {
-        if (!out.has(cmd.name))
-          out.set(cmd.name, cmd);
-      }
-      return [...out.values()];
-    }
-    function findSlashCommand2(cmds, name) {
-      const want = name.replace(/^\//, "").trim().toLowerCase();
-      return cmds.find((c) => c.name === want);
-    }
-    function expandCommand2(cmd, argString, workDir) {
-      const args = argString.trim();
-      const positional = args ? args.split(/\s+/) : [];
-      let out = cmd.body;
-      out = out.replace(/!`([^`]+)`/g, (_m, c) => {
-        try {
-          const stdout = (0, child_process_1.execSync)(c, { cwd: workDir, encoding: "utf-8", timeout: 15e3, stdio: ["ignore", "pipe", "pipe"] });
-          return stdout.trim();
-        } catch (err) {
-          return `[command failed: ${c} \u2014 ${err.message}]`;
-        }
-      });
-      out = out.replace(/(^|\s)@([^\s]+)/g, (_m, lead, rel) => {
-        const abs = path5.isAbsolute(rel) ? rel : path5.join(workDir, rel);
-        try {
-          const content = fs6.readFileSync(abs, "utf-8").slice(0, 12e3);
-          return `${lead}
-[File: ${rel}]
-\`\`\`
-${content}
-\`\`\`
-`;
-        } catch {
-          return `${lead}[missing file: ${rel}]`;
-        }
-      });
-      out = out.replace(/\$(\d+)/g, (_m, n) => positional[Number(n) - 1] ?? "");
-      const hadArgsToken = /\$ARGUMENTS/.test(out);
-      out = out.replace(/\$ARGUMENTS/g, args);
-      if (!hadArgsToken && !/\$\d+/.test(cmd.body) && args) {
-        out = `${out}
-
-${args}`;
-      }
-      return out.trim();
-    }
-  }
-});
-
 // ../core/dist/permissions/destructive.js
 var require_destructive = __commonJS({
   "../core/dist/permissions/destructive.js"(exports2) {
@@ -16401,6 +17412,8 @@ var require_dist2 = __commonJS({
     __exportStar(require_crossFile(), exports2);
     __exportStar(require_flaky(), exports2);
     __exportStar(require_claimEvidence(), exports2);
+    __exportStar(require_memory(), exports2);
+    __exportStar(require_skills(), exports2);
     __exportStar(require_client2(), exports2);
     __exportStar(require_httpClient(), exports2);
     __exportStar(require_manager(), exports2);
@@ -22186,6 +23199,25 @@ var MarkdownStreamRenderer = class {
     for (const line of parts)
       this._line(line);
   }
+  /**
+   * Drop all buffered/partial state without emitting it.
+   *
+   * Used when a stream died mid-render and the same turn is being restarted: the
+   * replacement attempt re-sends the response from the beginning, so any half-parsed
+   * line, unterminated code fence or partially accumulated table from the dead attempt
+   * must be discarded. Flushing instead would print a fragment and then leave the
+   * renderer in `_inCode`/`_tbl` state that corrupts everything the retry prints.
+   *
+   * Note this only resets the PARSER — characters already written to stdout have
+   * scrolled away and cannot be unprinted; the caller prints a visible restart marker
+   * so the duplicated prefix is explained rather than silently confusing.
+   */
+  reset() {
+    this._buf = "";
+    this._inCode = false;
+    this._codeLang = "";
+    this._tbl = [];
+  }
   flush() {
     if (this._buf) {
       this._line(this._buf);
@@ -22883,11 +23915,15 @@ var import_code_core2 = __toESM(require_dist2());
 var autoApproved = /* @__PURE__ */ new Set();
 var _rules = { allow: [], ask: [], deny: [] };
 var _workDir = process.cwd();
+var _mode = "auto";
 function initPermissions(workDir) {
   _workDir = workDir;
   _rules = (0, import_code_core2.loadSettings)(workDir).permissions;
   return _rules;
 }
+function setMode(mode) {
+  _mode = mode || "auto";
+}
 function setAutoApprove(category) {
   autoApproved.add(category);
 }
@@ -22944,6 +23980,7 @@ async function requestPermission(req) {
     "todo_write",
     "memory_read",
     "memory_write",
+    "use_skill",
     "notebook_read",
     "get_diagnostics",
     "go_to_definition",
@@ -22955,6 +23992,10 @@ async function requestPermission(req) {
   ];
   if (readOnlyTools.includes(tool))
     return true;
+  if (_mode === "plan") {
+    console.error(source_default.yellow(`  \u2298 Plan mode \u2014 refused ${tool} (read-only until you switch mode).`));
+    return false;
+  }
   if (tool === "write_file" || tool === "create_file") {
     if (isAutoApproved("write"))
       return true;
@@ -23356,6 +24397,23 @@ function tryExec(cmd, cwd) {
     return void 0;
   }
 }
+var BILLING_URL = "https://app.nexrall.com/?settings=billing";
+function hyperlink(label, url) {
+  return `\x1B]8;;${url}\x1B\\${label}\x1B]8;;\x1B\\`;
+}
+var lastBalanceNoticeState = null;
+function printBalanceNotice(balance, zero) {
+  const state = zero ? "zero" : "low";
+  if (lastBalanceNoticeState === state)
+    return;
+  lastBalanceNoticeState = state;
+  const title = zero ? "Out of balance" : "Balance running low";
+  const detail = zero ? "You're out of funds \u2014 top up to keep the agent working." : `Your wallet is under $5${typeof balance === "number" ? ` ($${balance.toFixed(2)} left)` : ""}. Top up before it runs out.`;
+  console.log();
+  console.log(source_default.bgYellow.black(` ${title} `) + "  " + source_default.dim(detail));
+  console.log("  " + source_default.yellow(hyperlink("\u2192 Top up", BILLING_URL)) + source_default.dim(`  (${BILLING_URL})`));
+  console.log();
+}
 function collectEnv(workDir) {
   return {
     cwd: workDir,
@@ -23383,10 +24441,9 @@ var tryRead = (p) => {
 };
 function readNexrallMd(workDir) {
   const parts = [];
-  const memContent = tryRead(path3.join(os4.homedir(), ".nexrall", "memory.md"));
+  const memContent = (0, import_code_core3.readAllMemory)(workDir);
   if (memContent)
-    parts.push(`[Memories from previous conversations]
-${memContent}`);
+    parts.push(memContent);
   const globalContent = tryRead(path3.join(os4.homedir(), ".nexrall", "nexrall.md"));
   if (globalContent)
     parts.push(`[Global instructions]
@@ -23430,6 +24487,7 @@ async function runTurn(messages, modelAlias, workDir, abortSignal, env2, nexrall
   let toolStartTime = 0;
   let lastToolName = "";
   let thinkingTokens = 0;
+  setMode(mode);
   process.stdout.write("\n");
   const result = await (0, import_code_core3.runAgentLoop)(messages, {
     workDir,
@@ -23456,6 +24514,18 @@ async function runTurn(messages, modelAlias, workDir, abortSignal, env2, nexrall
       spinner.stop();
       mdRender.feed(text);
     },
+    // System notices (mid-run auto-prune/auto-compact housekeeping) are NOT part
+    // of the model's own reply — used to go through onText, which spliced
+    // "♻️ Trimmed ~0.3MB…" straight into the markdown stream renderer as if the
+    // model itself had said it. Print it as its own dim line instead (same
+    // treatment as the resume-time compaction notice below).
+    onNotice: (text) => {
+      if (abortSignal.aborted)
+        return;
+      mdRender.flush();
+      spinner.stop();
+      console.log(source_default.dim(`  ${text}`));
+    },
     onToolUse: (name, input) => {
       if (abortSignal.aborted)
         return;
@@ -23473,8 +24543,50 @@ async function runTurn(messages, modelAlias, workDir, abortSignal, env2, nexrall
       console.log(formatToolResult(lastToolName, res, durationMs));
       toolStartTime = 0;
     },
-    onUsage: (u) => {
-      lastUsage = u;
+    // 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
+    // would print a token count for output the user never saw.
+    onUsage: (u, partial) => {
+      if (!partial)
+        lastUsage = u;
+    },
+    // A transient disconnect (network drop, machine sleep/wake, overloaded upstream)
+    // is retried transparently by the network layer — without this, that pause was
+    // completely invisible: the CLI just appeared to freeze and then resume with no
+    // explanation. Reuse the same spinner to show what's actually happening.
+    onRetry: (attempt, _maxAttempts, reason) => {
+      if (abortSignal.aborted)
+        return;
+      spinner.start(`${reason}\u2026 (attempt ${attempt})`);
+    },
+    onRetryResolved: () => {
+      spinner.stop();
+    },
+    // The stream died after part of the answer had already been printed, and the
+    // turn is being restarted from the top. Providing this handler is what OPTS US
+    // IN to post-render restarts at all (see AgentLoopOptions.onStreamRestart) —
+    // without it a mid-answer disconnect kills the whole turn.
+    //
+    // A terminal can't unprint scrolled-away output, so instead of pretending the
+    // fragment never happened we (a) reset the markdown parser so the dead attempt's
+    // half-open code fence/table can't corrupt everything the retry prints, and
+    // (b) draw an explicit marker so the user understands why the answer restarts.
+    onStreamRestart: (reason, discardedChars) => {
+      if (abortSignal.aborted)
+        return;
+      spinner.stop();
+      mdRender.reset();
+      if (discardedChars > 0) {
+        console.log(
+          "\n" + source_default.yellow("  \u21BA Connection dropped mid-answer \u2014 restarting this response.") + source_default.dim(`
+    (${reason}. The ${discardedChars} characters above are incomplete; the full answer follows.)`) + "\n"
+        );
+      }
+    },
+    onBalanceStatus: (balance, zero) => {
+      spinner.stop();
+      mdRender.flush();
+      printBalanceNotice(balance, zero);
     },
     requestPermission,
     checkpointManager,
@@ -23508,6 +24620,13 @@ async function runTurnHeadless(messages, modelAlias, workDir, _abortSignal, env2
       resultText += text;
       emit({ type: "text", text });
     },
+    // System notice (mid-run auto-prune/auto-compact) — emit as its own event
+    // type instead of falling through to onText, so a stream-json consumer
+    // doesn't see compaction housekeeping text mixed into the model's `text`
+    // events or accumulated into resultText.
+    onNotice: (text) => {
+      emit({ type: "notice", text });
+    },
     onToolUse: (name, input) => {
       emit({ type: "tool_use", tool: name, input });
     },
@@ -23515,9 +24634,26 @@ async function runTurnHeadless(messages, modelAlias, workDir, _abortSignal, env2
       toolCallCount++;
       emit({ type: "tool_result", tool: name, ok: res.error === void 0, ...res.error ? { error: res.error } : {} });
     },
-    onUsage: (u) => {
-      lastUsage = u;
-      emit({ type: "usage", usage: u });
+    // Headless consumers get the partial report too — tagged, so a script can account
+    // for the real cost of a restarted turn — but it never becomes `lastUsage`, which
+    // represents the turn's actual output.
+    onUsage: (u, partial) => {
+      if (!partial)
+        lastUsage = u;
+      emit({ type: "usage", usage: u, ...partial ? { partial: true } : {} });
+    },
+    onRetry: (attempt, maxAttempts, reason) => {
+      emit({ type: "retry", attempt, max_attempts: maxAttempts, reason });
+    },
+    // Headless consumers parse NDJSON, so a restart is trivially clean for them:
+    // they simply drop every `text`/`thinking` event seen since the turn started.
+    // Emitting it also opts headless mode into post-render restarts, so a scripted
+    // /CI run survives a blip instead of exiting non-zero halfway through.
+    onStreamRestart: (reason, discardedChars) => {
+      emit({ type: "stream_restart", reason, discarded_chars: discardedChars });
+    },
+    onBalanceStatus: (balance, zero) => {
+      emit({ type: "balance_status", balance, zero, billing_url: BILLING_URL });
     },
     // Headless → auto-approve (no TTY to ask on). Destructive/irreversible
     // commands (DB drops, force-push, terraform destroy…) fail CLOSED here: with
@@ -23559,6 +24695,7 @@ function printHelp() {
     ["/rewind [id]", "List file checkpoints, or roll back to one"],
     ["/compact", "Summarize conversation to save tokens"],
     ["/init", "Generate nexrall.md for this project"],
+    ["/memory [global] [clear]", "View persistent memory (project or global); /memory clear to wipe"],
     ["/help", "Show this help"],
     ["/model [turbo|pro|ultra]", "Switch model"],
     ["/mode [ask|edit|plan|auto]", "Set agent mode"],
@@ -23566,7 +24703,7 @@ function printHelp() {
     ["/yolo", "Auto-approve all permissions"],
     ["/balance", "Show wallet balance"],
     ["/add <filepath>", "Add a file to conversation context"],
-    ["/commands", "List custom commands (.nexrall/commands/*.md)"],
+    ["/skills", "List skills (.nexrall/skills/<name>/SKILL.md or .nexrall/commands/*.md) \u2014 the model can also auto-invoke these"],
     ["/plugins", "List installed plugins (.nexrall/plugins/)"],
     ["/update", "Update nex to the latest version"]
   ];
@@ -23625,9 +24762,9 @@ async function startChatSession(options) {
   const ruleCount = permRules.allow.length + permRules.ask.length + permRules.deny.length;
   if (ruleCount && !headless)
     console.log(source_default.dim(`  ${ruleCount} permission rule(s) loaded`));
-  let slashCommands = (0, import_code_core3.loadSlashCommands)(workDir);
-  if (slashCommands.length && !headless)
-    console.log(source_default.dim(`  ${slashCommands.length} custom command(s) loaded`));
+  let skills = (0, import_code_core3.loadSkills)(workDir);
+  if (skills.length && !headless)
+    console.log(source_default.dim(`  ${skills.length} skill(s) loaded`));
   if (headless && !options.prompt && !options.stdinText) {
     process.stdout.write(JSON.stringify({ type: "error", error: "--output-format json/stream-json requires a one-shot prompt (or piped stdin)." }) + "\n");
     process.exit(1);
@@ -23642,9 +24779,23 @@ async function startChatSession(options) {
     messages = stored.messages;
     sessionId = stored.id;
     sessionTitle = stored.title;
-    console.log(source_default.green(`  Resumed session: ${source_default.bold(stored.title.slice(0, 60))}`));
-    console.log(source_default.dim(`  ${messages.length} messages restored`));
-    console.log();
+    try {
+      const compacted = await (0, import_code_core3.compactMessagesForResume)(messages, {
+        workDir,
+        model: modelAlias,
+        clientType: "cli",
+        onNotice: (text) => {
+          if (!headless)
+            console.log(source_default.dim(text.trim()));
+        }
+      });
+    } catch {
+    }
+    if (!headless) {
+      console.log(source_default.green(`  Resumed session: ${source_default.bold(stored.title.slice(0, 60))}`));
+      console.log(source_default.dim(`  ${messages.length} messages restored`));
+      console.log();
+    }
   }
   const checkpoints = new import_code_core3.CheckpointManager(workDir, sessionId);
   const updateTitle = () => {
@@ -23654,6 +24805,19 @@ async function startChatSession(options) {
     const raw = first?.content[0]?.text ?? "";
     sessionTitle = raw.length > 60 ? raw.slice(0, 60) + "\u2026" : raw;
   };
+  const recoverTurn = (err, current) => {
+    const salvaged = (0, import_code_core3.salvageHistory)(err);
+    console.error("\n" + source_default.red("Error: ") + String(err.message));
+    if (!salvaged)
+      return current;
+    const rounds = err.progressCount ?? 1;
+    console.error(
+      source_default.dim(
+        `  Kept the ${rounds} step${rounds === 1 ? "" : "s"} completed before the interruption \u2014 send "continue" to pick up where it stopped.`
+      )
+    );
+    return salvaged;
+  };
   let lastProgressSave = 0;
   const saveProgress = (live) => {
     const now = Date.now();
@@ -23689,10 +24853,27 @@ ${text}` : "");
       updateTitle();
       saveSession(sessionId, sessionTitle, workDir, messages);
     } catch (err) {
+      const salvaged = (0, import_code_core3.salvageHistory)(err);
+      if (salvaged) {
+        messages = salvaged;
+        try {
+          updateTitle();
+          saveSession(sessionId, sessionTitle || "Untitled", workDir, messages);
+          checkpoints.commitTurn();
+        } catch {
+        }
+      }
       if (options.outputFormat === "json" || options.outputFormat === "stream-json") {
-        process.stdout.write(JSON.stringify({ type: "error", error: String(err.message) }) + "\n");
+        process.stdout.write(JSON.stringify({
+          type: "error",
+          error: String(err.message),
+          ...salvaged ? { resumable: true, messagesCompleted: salvaged.length } : {}
+        }) + "\n");
       } else {
         console.error(source_default.red("\nError: ") + String(err.message));
+        if (salvaged) {
+          console.error(source_default.dim("  Progress was saved \u2014 run `nex --continue` to resume this session."));
+        }
       }
       process.exit(1);
     } finally {
@@ -23789,6 +24970,15 @@ ${text}` : "");
           messages = stored.messages;
           sessionId = stored.id;
           sessionTitle = stored.title;
+          try {
+            await (0, import_code_core3.compactMessagesForResume)(messages, {
+              workDir,
+              model: modelAlias,
+              clientType: "cli",
+              onNotice: (text) => console.log(source_default.dim(text.trim()))
+            });
+          } catch {
+          }
           console.log(source_default.green(`  Resumed: ${source_default.bold(stored.title.slice(0, 60))}`));
           console.log(source_default.dim(`  ${messages.length} messages restored`));
           rl.prompt();
@@ -23945,6 +25135,49 @@ ${dirList}`;
           rl.prompt();
           return;
         }
+        case "/memory": {
+          const memArgs = arg.toLowerCase().split(/\s+/).filter(Boolean);
+          const wantsGlobalOnly = memArgs.includes("global");
+          const wantsClear = memArgs.includes("clear");
+          const memScope = wantsGlobalOnly ? "global" : "project";
+          if (wantsClear) {
+            rl.pause();
+            const rl2 = readline3.createInterface({ input: process.stdin, output: process.stdout });
+            const label = memScope === "global" ? "GLOBAL" : "this PROJECT's";
+            const answer = await new Promise((resolve3) => rl2.question(source_default.yellow(`  Clear ${label} memory? This cannot be undone. [y/n] `), (a) => {
+              rl2.close();
+              resolve3(a.trim());
+            }));
+            if (answer === "y" || answer === "yes") {
+              (0, import_code_core3.clearMemory)(memScope, workDir);
+              console.log(source_default.green(`  ${memScope === "global" ? "Global" : "Project"} memory cleared.`));
+            } else {
+              console.log(source_default.dim("  Cancelled."));
+            }
+            rl.resume();
+            rl.prompt();
+            return;
+          }
+          console.log();
+          if (wantsGlobalOnly) {
+            const stats = (0, import_code_core3.memoryStats)("global");
+            const content = (0, import_code_core3.readMemory)("global");
+            console.log(source_default.bold("  Global memory ") + source_default.dim(`(${stats.entries} entries, ${(stats.bytes / 1024).toFixed(1)}KB) \u2014 ${stats.file}`));
+            console.log();
+            console.log(content || source_default.dim("  No global memories saved yet."));
+          } else {
+            const projStats = (0, import_code_core3.memoryStats)("project", workDir);
+            const globalStats = (0, import_code_core3.memoryStats)("global");
+            console.log(source_default.bold("  Memory") + source_default.dim(`  \u2014 project: ${projStats.entries} entries (${(projStats.bytes / 1024).toFixed(1)}KB)  \xB7  global: ${globalStats.entries} entries (${(globalStats.bytes / 1024).toFixed(1)}KB)`));
+            console.log();
+            const merged = (0, import_code_core3.readAllMemory)(workDir);
+            console.log(merged || source_default.dim("  No memories saved yet."));
+          }
+          console.log();
+          console.log(source_default.dim("  Tip: /memory global  \xB7  /memory clear  \xB7  /memory global clear"));
+          rl.prompt();
+          return;
+        }
         case "/help":
           printHelp();
           rl.prompt();
@@ -24048,20 +25281,23 @@ ${content}
             }
             console.log();
           }
-          slashCommands = (0, import_code_core3.loadSlashCommands)(workDir);
+          skills = (0, import_code_core3.loadSkills)(workDir);
           rl.prompt();
           return;
         }
+        case "/skills":
         case "/commands": {
-          slashCommands = (0, import_code_core3.loadSlashCommands)(workDir);
-          if (!slashCommands.length) {
-            console.log(source_default.dim("  No custom commands. Add .nexrall/commands/<name>.md to create one."));
+          skills = (0, import_code_core3.loadSkills)(workDir);
+          const invocable = (0, import_code_core3.userInvokableSkills)(skills);
+          if (!invocable.length) {
+            console.log(source_default.dim("  No skills. Add .nexrall/skills/<name>/SKILL.md (or .nexrall/commands/<name>.md) to create one."));
           } else {
             console.log();
-            console.log(source_default.bold("  Custom commands:"));
-            for (const c of slashCommands) {
-              const scope = c.source === "project" ? "" : source_default.dim(` (${c.source})`);
-              console.log("  " + source_default.cyan(`/${c.name}`.padEnd(20)) + source_default.dim(c.description) + scope);
+            console.log(source_default.bold("  Skills:"));
+            for (const s2 of invocable) {
+              const scope = s2.source === "project" ? "" : source_default.dim(` (${s2.source})`);
+              const auto = s2.disableModelInvocation ? source_default.dim(" [manual only]") : "";
+              console.log("  " + source_default.cyan(`/${s2.name}`.padEnd(20)) + source_default.dim(s2.description) + scope + auto);
             }
             console.log();
           }
@@ -24069,14 +25305,14 @@ ${content}
           return;
         }
         default: {
-          const custom = (0, import_code_core3.findSlashCommand)(slashCommands, cmd);
+          const custom = (0, import_code_core3.findSkill)(skills, cmd);
           if (!custom) {
             console.log(source_default.red(`  Unknown command: ${cmd}`));
-            console.log(source_default.dim("  Type /help for built-ins or /commands for custom ones."));
+            console.log(source_default.dim("  Type /help for built-ins or /skills for custom ones."));
             rl.prompt();
             return;
           }
-          const expanded = (0, import_code_core3.expandCommand)(custom, arg, workDir);
+          const expanded = (0, import_code_core3.expandSkill)(custom, arg, workDir);
           const turnModel = custom.model ?? modelAlias;
           const turnMode = custom.mode ?? agentMode;
           console.log(source_default.dim(`  Running /${custom.name}\u2026`));
@@ -24091,7 +25327,9 @@ ${content}
             updateTitle();
             saveSession(sessionId, sessionTitle, workDir, messages);
           } catch (err) {
-            console.error("\n" + source_default.red("Error: ") + String(err.message));
+            messages = recoverTurn(err, messages);
+            updateTitle();
+            saveSession(sessionId, sessionTitle || "Untitled", workDir, messages);
           } finally {
             agentRunning = false;
             checkpoints.commitTurn();
@@ -24113,7 +25351,9 @@ ${content}
       updateTitle();
       saveSession(sessionId, sessionTitle, workDir, messages);
     } catch (err) {
-      console.error("\n" + source_default.red("Error: ") + String(err.message));
+      messages = recoverTurn(err, messages);
+      updateTitle();
+      saveSession(sessionId, sessionTitle || "Untitled", workDir, messages);
     } finally {
       agentRunning = false;
       checkpoints.commitTurn();
@@ -24335,7 +25575,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.2");
+program2.name("nex").description("Nexrall Code \u2014 AI coding assistant (powered by Nexrall)").version("0.5.17");
 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) => {