nexrall-code 0.5.52 → 0.5.54

package/dist/index.js

@@ -9982,7 +9982,7 @@ var require_client = __commonJS({
     }
     var MAX_TOTAL_ATTEMPTS = (MAX_RETRIES + 1) * (MAX_RETRIES + 1);
     async function streamChat(messages, options, onEvent) {
-      const { model, env: env3, editorContext, nexrallMd, mode, effort, clientType, abortSignal, extraTools, agents, skills, allowRestartAfterRender } = options;
+      const { model, env: env3, editorContext, nexrallMd, mode, effort, clientType, abortSignal, extraTools, agents, skills, allowRestartAfterRender, canWriteSharedMemory, hasOwnAgentStore } = options;
       let turnId = (0, crypto_1.randomUUID)();
       const controller = new AbortController();
       if (abortSignal?.aborted)
@@ -10023,7 +10023,7 @@ var require_client = __commonJS({
           {
             method: "POST",
             headers: authHeaders(),
-            body: JSON.stringify({ messages, model, env: env3, editorContext, nexrallMd, mode, effort, clientType, extraTools, agents, skills, turnId }),
+            body: JSON.stringify({ messages, model, env: env3, editorContext, nexrallMd, mode, effort, clientType, extraTools, agents, skills, turnId, canWriteSharedMemory, hasOwnAgentStore }),
             signal: controller.signal
           }
         ];
@@ -11012,13 +11012,18 @@ var require_memory = __commonJS({
       };
     }();
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.MEMORY_HARD_CAP_BYTES = exports.MEMORY_COMPACT_TRIGGER_BYTES = exports.MEMORY_MAX_BYTES = exports.MEMORY_ENTRY_MAX_CHARS = void 0;
+    exports.AGENT_MEMORY_MAX_BYTES = exports.AGENT_MEMORY_INJECT_MAX = exports.MEMORY_HARD_CAP_BYTES = exports.MEMORY_COMPACT_TRIGGER_BYTES = exports.MEMORY_MAX_BYTES = exports.MEMORY_ENTRY_MAX_CHARS = void 0;
     exports.memoryFilePath = memoryFilePath;
     exports.writeMemory = writeMemory;
     exports.readMemory = readMemory2;
     exports.readAllMemory = readAllMemory2;
     exports.clearMemory = clearMemory2;
     exports.memoryStats = memoryStats2;
+    exports.isSafeAgentName = isSafeAgentName;
+    exports.agentMemoryPath = agentMemoryPath;
+    exports.readAgentMemory = readAgentMemory;
+    exports.writeAgentMemory = writeAgentMemory;
+    exports.agentMemoryPreamble = agentMemoryPreamble;
     exports.compactMemoryIfNeeded = compactMemoryIfNeeded2;
     var fs9 = __importStar(__require("fs"));
     var os6 = __importStar(__require("os"));
@@ -11127,6 +11132,71 @@ ${projMem}`);
       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 };
     }
+    exports.AGENT_MEMORY_INJECT_MAX = 8e3;
+    exports.AGENT_MEMORY_MAX_BYTES = 24e3;
+    function isSafeAgentName(name) {
+      return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name) && !name.includes("..");
+    }
+    function agentMemoryPath(agentName, scope, workDir) {
+      if (!isSafeAgentName(agentName))
+        return null;
+      const file = `${agentName}.md`;
+      let dir;
+      if (scope === "user") {
+        dir = path6.join(MEMORY_ROOT, "agent-memory");
+      } else {
+        if (!workDir)
+          return null;
+        dir = path6.join(path6.resolve(workDir), ".nexrall", scope === "local" ? "agent-memory-local" : "agent-memory");
+      }
+      const full = path6.join(dir, file);
+      const rel = path6.relative(dir, full);
+      if (rel.startsWith("..") || path6.isAbsolute(rel))
+        return null;
+      return full;
+    }
+    function readAgentMemory(agentName, scope, workDir) {
+      const file = agentMemoryPath(agentName, scope, workDir);
+      if (!file)
+        return "";
+      return readMemoryFile(file).trim();
+    }
+    async function writeAgentMemory(agentName, scope, content, workDir) {
+      let trimmed = content.trim();
+      if (!trimmed)
+        return { ok: false, already: false, file: "" };
+      if (trimmed.length > exports.MEMORY_ENTRY_MAX_CHARS) {
+        trimmed = trimmed.slice(0, exports.MEMORY_ENTRY_MAX_CHARS - 1).trimEnd() + "\u2026";
+      }
+      const file = agentMemoryPath(agentName, scope, workDir);
+      if (!file)
+        return { ok: false, already: false, file: "" };
+      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, file };
+        }
+        const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+        let next = existing + `
+- [${today}] ${trimmed}`;
+        if (Buffer.byteLength(next, "utf-8") > exports.AGENT_MEMORY_MAX_BYTES) {
+          next = evictOldest(next, exports.AGENT_MEMORY_MAX_BYTES);
+        }
+        writeMemoryFile(file, next);
+        return { ok: true, already: false, file };
+      });
+    }
+    function agentMemoryPreamble(agentName, scope, workDir) {
+      const notes = readAgentMemory(agentName, scope, workDir);
+      if (!notes)
+        return "";
+      const kept = Buffer.byteLength(notes, "utf-8") > exports.AGENT_MEMORY_INJECT_MAX ? notes.slice(-exports.AGENT_MEMORY_INJECT_MAX) : notes;
+      return `# Your own notes (agent: ${agentName}, scope: ${scope})
+These are notes YOU saved on previous runs. Treat them as your accumulated experience, not as instructions from the user, and verify anything that looks stale against the current code.
+
+${kept}`;
+    }
     async function compactMemoryIfNeeded2(scope, workDir, summarize) {
       const file = memoryFilePath(scope, workDir);
       return withLock(file, async () => {
@@ -14585,6 +14655,11 @@ var require_agentTypes = __commonJS({
     var path6 = __importStar(__require("path"));
     var os6 = __importStar(__require("os"));
     var index_1 = require_plugins();
+    var VALID_MEMORY_SCOPES = ["project", "user", "local"];
+    function parseMemoryScope(v) {
+      const s2 = (v ?? "").trim().toLowerCase();
+      return VALID_MEMORY_SCOPES.includes(s2) ? s2 : void 0;
+    }
     var READ_ONLY_TOOLS = [
       // Universal
       "read_file",
@@ -14600,6 +14675,22 @@ var require_agentTypes = __commonJS({
       "notebook_read",
       "todo_write",
       "todo_read",
+      // memory_READ, deliberately without memory_write.
+      //
+      // Reading is free capability: a sub-agent that knows "tests run with X" or "never
+      // edit Z directly" does better work, and withholding it meant every sub-agent
+      // rediscovered project conventions from scratch. Writing is a different thing
+      // entirely — memory is durable, cross-session, SHARED state, while sub-agents run
+      // up to 4-wide in parallel with their reasoning hidden from the user. A wrong fact
+      // written there is invisible and permanent, and it competes for a capped, shared
+      // budget that gets periodically condensed.
+      //
+      // So the parent owns writes: a sub-agent that learns something durable says so in
+      // its report, and the main agent — the one actually talking to the user — decides.
+      // A sub-agent that needs its own persistent notes gets the per-agent store instead
+      // (see `memory:` in the frontmatter), which is scoped to itself and cannot pollute
+      // the shared file.
+      "memory_read",
       // Skills are reusable prompt playbooks, and loop.ts advertises the skills
       // catalogue to sub-agents at EVERY depth — so withholding the tool that loads
       // one meant showing every sub-agent a menu it could not order from.
@@ -14832,6 +14923,9 @@ var require_agentTypes = __commonJS({
       "stock_photo",
       "open_in_browser",
       "task",
+      // Granted by a `memory:` scope rather than listed in a `tools:` line, but a user may
+      // still name it explicitly — so it must validate rather than be flagged as a typo.
+      "agent_memory_write",
       "get_symbols",
       "get_workspace_symbols",
       "find_references",
@@ -14845,7 +14939,8 @@ var require_agentTypes = __commonJS({
       "tools",
       "model",
       "test_files_only",
-      "testfilesonly"
+      "testfilesonly",
+      "memory"
     ]);
     var VALID_MODELS = ["turbo", "pro", "ultra"];
     function parseFrontmatter(raw) {
@@ -14918,6 +15013,13 @@ var require_agentTypes = __commonJS({
               message: "has no `description:` \u2014 that text is the ONLY thing the model uses to decide when to delegate to this agent, so it will rarely be picked."
             });
           }
+          if (meta.memory !== void 0 && parseMemoryScope(meta.memory) === void 0) {
+            warnings.push({
+              file: full,
+              agent: name,
+              message: `has memory: "${meta.memory}", which is not a valid scope \u2014 use one of ${VALID_MEMORY_SCOPES.join(", ")}, or omit the line to give this agent no persistent notes.`
+            });
+          }
           if (meta.model !== void 0 && parseModel(meta.model) === void 0) {
             warnings.push({
               file: full,
@@ -14960,7 +15062,13 @@ var require_agentTypes = __commonJS({
           // `testFilesOnly`) lets anyone build a test-writing agent that genuinely
           // cannot touch production source, rather than only the builtin getting
           // that guarantee.
-          ...parseBool(meta.test_files_only ?? meta.testfilesonly) ? { testFilesOnly: true } : {}
+          ...parseBool(meta.test_files_only ?? meta.testfilesonly) ? { testFilesOnly: true } : {},
+          // The `ok &&` is defensive, not load-bearing: parseFrontmatter already returns an
+          // EMPTY meta when it cannot find a `---` block, so `meta.memory` is undefined on
+          // that path regardless. It stays because the guarantee we want — an unreadable
+          // definition never receives a writable store — should survive parseFrontmatter
+          // being changed to salvage partial metadata, which is a plausible future edit.
+          ...ok && parseMemoryScope(meta.memory) ? { memory: parseMemoryScope(meta.memory) } : {}
         });
       }
     }
@@ -15763,8 +15871,10 @@ var require_loop = __commonJS({
       };
     }();
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.VERIFY_CMD_RE = exports.WRITE_TOOL_NAMES = exports.ToolNotAllowedError = exports._stallLimits = void 0;
+    exports.VERIFY_CMD_RE = exports.WRITE_TOOL_NAMES = exports.ToolNotAllowedError = exports.AGENT_MEMORY_TOOL_SCHEMA = exports.AGENT_MEMORY_TOOL = exports._stallLimits = void 0;
     exports.errorRoundSignature = errorRoundSignature;
+    exports.executeAgentMemoryWrite = executeAgentMemoryWrite;
+    exports.stopReasonNotice = stopReasonNotice;
     exports.resolveMaxIterations = resolveMaxIterations;
     exports.createLimiter = createLimiter;
     exports.extractSubTaskText = extractSubTaskText;
@@ -15902,6 +16012,72 @@ var require_loop = __commonJS({
       return errored.map(({ name, error }) => `${name}:${String(error).slice(0, 200)}`).sort().join("|");
     }
     exports._stallLimits = { STALL_LIMIT, REPEAT_STALL_LIMIT };
+    exports.AGENT_MEMORY_TOOL = "agent_memory_write";
+    exports.AGENT_MEMORY_TOOL_SCHEMA = {
+      name: exports.AGENT_MEMORY_TOOL,
+      description: "Save a durable note to YOUR OWN persistent notes, which are injected into your prompt on future runs. Use this for lessons that will still be true next time \u2014 a convention this repo follows, a recurring bug pattern, a command that works, a dead end not worth retrying. These notes are PRIVATE to you: they are NOT shown to the user and NOT read by the main agent, so anything the user or the main agent needs to know must still go in your final message. One self-contained fact per call, a sentence or two. Do not save transient task details.",
+      input_schema: {
+        type: "object",
+        properties: {
+          content: { type: "string", description: "The single fact to remember, 1-2 sentences." }
+        },
+        required: ["content"]
+      }
+    };
+    async function executeAgentMemoryWrite(input, binding, workDir) {
+      if (!binding) {
+        return {
+          error: `${exports.AGENT_MEMORY_TOOL} is only available to a sub-agent whose definition declares a \`memory:\` scope. Put anything worth remembering in your final message instead.`
+        };
+      }
+      const content = typeof input.content === "string" ? input.content.trim() : "";
+      if (!content)
+        return { error: `${exports.AGENT_MEMORY_TOOL} requires a non-empty \`content\` string.` };
+      const res = await (0, memory_1.writeAgentMemory)(binding.agentName, binding.scope, content, workDir);
+      if (!res.ok) {
+        return {
+          error: `Could not save to the "${binding.agentName}" agent's ${binding.scope} notes. Either this scope needs a project directory (use \`memory: user\` for a store that works anywhere) or the agent name is not usable as a filename.`
+        };
+      }
+      return {
+        output: res.already ? "Already saved (a near-identical note exists) \u2014 nothing added." : `Saved to your ${binding.scope} notes. It will be in your prompt on your next run.`
+      };
+    }
+    function stopReasonNotice(reason, ctx = {}) {
+      switch (reason) {
+        case "clean":
+        case "aborted":
+        case "reported-elsewhere":
+          return null;
+        case "empty-response":
+          return `
+\u26A0\uFE0F The model returned an empty response, so nothing was done. This is usually a transient upstream hiccup \u2014 send "continue" to retry.
+`;
+        case "no-balance":
+          return `
+\u{1F4B3} Stopped: your balance is empty, so the request was rejected before it started. Top up and send "continue" \u2014 no tokens were used for this turn.
+`;
+        case "stalled":
+          return `
+\u{1F6D1} Stopped: the last ${STALL_LIMIT} tool rounds all failed, so the agent looked stuck. Fix the underlying error (or grant the needed permission) and send "continue".
+`;
+        case "stalled-repeat":
+          return `
+\u{1F6D1} Stopped: the same tool error repeated ${REPEAT_STALL_LIMIT} rounds in a row, so the agent was looping without making progress.` + (ctx.repeatError ? ` The recurring error was:
+${ctx.repeatError}
+` : "\n") + `Fix that underlying cause (or grant the needed permission) and send "continue".
+`;
+        case "budget":
+          return `
+\u23F8\uFE0F Stopped at the ${ctx.budget}-step safety limit \u2014 the task may be incomplete. Send "continue" to resume, or raise the limit via "maxIterations" in .nexrall/settings.json (or the NEXRALL_MAX_ITERATIONS env var). Auto-continue can be disabled with "autoContinue": false.
+`;
+        case "unknown":
+        default:
+          return `
+\u26A0\uFE0F The run ended unexpectedly without completing. Your work so far is preserved \u2014 send "continue" to resume.
+`;
+      }
+    }
     function resolveMaxIterations(optionValue, settingsRaw) {
       const fromEnv = Number(process.env.NEXRALL_MAX_ITERATIONS);
       const fromSettings = Number(settingsRaw.maxIterations);
@@ -16146,14 +16322,25 @@ ${tail}`;
 If you just created .nexrall/agents/` + requestedType + ".md, make sure the write finished in an EARLIER tool call than this one \u2014 a file written in the same batch may not be on disk yet."
         };
       }
+      const memoryScope = agent?.memory;
+      const agentMemoryNotes = agent && memoryScope ? (0, memory_1.agentMemoryPreamble)(agent.name, memoryScope, options.workDir) : "";
       const subNexrallMd = agent ? `# Sub-agent role: ${agent.name}
-${agent.prompt}` + (options.nexrallMd ? `
+${agent.prompt}` + (agentMemoryNotes ? `
+
+---
+
+${agentMemoryNotes}` : "") + (options.nexrallMd ? `
 
 ---
 
 ${options.nexrallMd}` : "") : options.nexrallMd;
       const allowed = agent?.tools ? new Set(agent.tools) : null;
+      if (allowed && memoryScope)
+        allowed.add(exports.AGENT_MEMORY_TOOL);
       const gatedPermission = async (req) => {
+        if (req.tool === exports.AGENT_MEMORY_TOOL && !(agent && memoryScope)) {
+          throw new ToolNotAllowedError(`\`${exports.AGENT_MEMORY_TOOL}\` is only available to a sub-agent whose definition declares a \`memory:\` scope (project, user or local). Report anything worth remembering in your final message instead \u2014 the main agent decides what to persist.`);
+        }
         if (allowed && !allowed.has(req.tool)) {
           throw new ToolNotAllowedError(`The "${agent.name}" sub-agent is not allowed to use \`${req.tool}\` \u2014 it is not in that agent's tool allowlist. This is a restriction of the agent definition, NOT a user decision: do not ask for approval, use one of the tools you do have, or report back that the task needs a different agent.`);
         }
@@ -16177,6 +16364,11 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
           _depth: depth + 1,
           _agentScope: `sub_${++_subTaskCounter}`,
           // isolated todo store per sub-agent
+          // Only set when the agent opted in, so the tool is inert for everyone else.
+          ...agent && memoryScope ? { _agentMemory: { agentName: agent.name, scope: memoryScope } } : {},
+          // The same set `gatedPermission` enforces above, so prompt and permission agree
+          // by construction instead of by two people remembering to update both.
+          ...allowed ? { _allowedTools: allowed } : {},
           editorContext: null,
           // fresh isolated context for sub-agent
           model: agent?.model ?? options.model,
@@ -16651,9 +16843,8 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
       let lastPromptTokens = 0;
       let compacting = false;
       const hardCap = autoContinue ? Math.max(maxIterations, MAX_ITERATIONS_CEILING) : maxIterations;
-      let completedCleanly = false;
+      let stopReason = "unknown";
       let completedRounds = 0;
-      let stalledOut = false;
       let consecutiveErrorRounds = 0;
       let repeatedErrorRounds = 0;
       let lastErrorSignature = "";
@@ -16671,8 +16862,10 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
       let compactDisabled = false;
       try {
         for (; iteration < budget; iteration++) {
-          if (options.abortSignal?.aborted)
+          if (options.abortSignal?.aborted) {
+            stopReason = "aborted";
             break;
+          }
           let bodyBytes = estimateBodyBytes2(messages);
           const prunePressure = lastPromptTokens > contextWindow * AUTO_PRUNE_THRESHOLD;
           const tokenPressure = lastPromptTokens > contextWindow * AUTO_COMPACT_THRESHOLD;
@@ -16768,7 +16961,22 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
               nexrallMd: planAwareNexrallMd,
               clientType: options.clientType,
               abortSignal: options.abortSignal,
-              extraTools: options.mcpManager?.getAnthropicTools(),
+              // MCP tools, plus the per-agent memory tool when (and only when) this run
+              // is a sub-agent that declared a `memory:` scope. Declaring it through
+              // extraTools rather than the backend's static catalogue keeps it invisible
+              // to every other run: a tool the model cannot see is one it cannot try,
+              // which is better than advertising it everywhere and refusing it at the gate.
+              extraTools: [
+                ...options.mcpManager?.getAnthropicTools() ?? [],
+                ...options._agentMemory ? [exports.AGENT_MEMORY_TOOL_SCHEMA] : []
+              ],
+              // Derived from the run's ACTUAL allowlist rather than asserted separately,
+              // so the prompt's memory instructions cannot drift from what is permitted.
+              // That drift is the bug being fixed: sub-agents were told they MUST call
+              // memory_write, which no sub-agent allowlist contains.
+              canWriteSharedMemory: options._allowedTools ? options._allowedTools.has("memory_write") : true,
+              // no allowlist = main agent = may write
+              hasOwnAgentStore: !!options._agentMemory,
               agents: agentsCatalogue || void 0,
               skills: skillsCatalogue || void 0,
               // Only allow a post-render restart when the caller actually implements the
@@ -16778,19 +16986,24 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
               allowRestartAfterRender: !!options.onStreamRestart
             }, onEvent);
           } catch (err) {
-            if (options.abortSignal?.aborted || err.name === "AbortError")
+            if (options.abortSignal?.aborted || err.name === "AbortError") {
+              stopReason = "aborted";
               break;
+            }
             const status = err.status;
             if (status === 402) {
               const balance = err.balance ?? 0;
               options.onBalanceStatus?.(balance, true);
+              stopReason = options.onBalanceStatus ? "reported-elsewhere" : "no-balance";
               break;
             }
             runSimpleHooks(hooks.OnError, options.workDir);
             throw new types_1.AgentTurnError(`Stream failed: ${err.message}`, trimToResumableBoundary(messages), completedRounds, err);
           }
-          if (options.abortSignal?.aborted)
+          if (options.abortSignal?.aborted) {
+            stopReason = "aborted";
             break;
+          }
           assistantMessage.content = assistantMessage.content.filter((b) => b.type !== "thinking" && b.type !== "redacted_thinking");
           if (assistantMessage.content.length === 0) {
             const queued = options.takePendingInput?.() ?? [];
@@ -16801,7 +17014,7 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
               continue;
             }
             runSimpleHooks(hooks.PostMessageComplete, options.workDir);
-            completedCleanly = true;
+            stopReason = "empty-response";
             break;
           }
           const { stopReason: _stopReason, ...historyMessage } = assistantMessage;
@@ -16872,7 +17085,7 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
               }
             }
             runSimpleHooks(hooks.PostMessageComplete, options.workDir);
-            completedCleanly = true;
+            stopReason = "clean";
             break;
           }
           const toolResults = await Promise.all(toolUseBlocks.map(async (block) => {
@@ -16914,6 +17127,11 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
                 result = { error: `Blocked by PreToolUse hook: ${pre.reason}` };
               } else {
                 try {
+                  if (name === exports.AGENT_MEMORY_TOOL) {
+                    result = await executeAgentMemoryWrite(input, options._agentMemory, options.workDir);
+                    options.onToolResult(name, result);
+                    return { block: { ...block, id }, result };
+                  }
                   const external = options.executeExternalTool ? await options.executeExternalTool(name, input) : null;
                   if (external !== null && external !== void 0) {
                     result = external;
@@ -17006,7 +17224,7 @@ ${result.output}` : `Error: ${result.error}` : result.output ?? "",
           const allErrored = toolResults.length > 0 && errored.length === toolResults.length;
           consecutiveErrorRounds = allErrored ? consecutiveErrorRounds + 1 : 0;
           if (consecutiveErrorRounds >= STALL_LIMIT) {
-            stalledOut = true;
+            stopReason = "stalled";
             break;
           }
           const errSignature = errorRoundSignature(errored.map(({ block, result }) => ({ name: block.name, error: String(result.error) })));
@@ -17017,7 +17235,7 @@ ${result.output}` : `Error: ${result.error}` : result.output ?? "",
             lastErrorSignature = errSignature;
           }
           if (repeatedErrorRounds >= REPEAT_STALL_LIMIT) {
-            stalledOut = true;
+            stopReason = "stalled-repeat";
             stalledRepeatError = errored[0] ? String(errored[0].result.error).slice(0, 300) : null;
             break;
           }
@@ -17028,21 +17246,13 @@ ${result.output}` : `Error: ${result.error}` : result.output ?? "",
 `);
           }
         }
-        if (!options.abortSignal?.aborted && !completedCleanly) {
-          if (stalledOut) {
-            (options.onNotice ?? options.onText)(stalledRepeatError ? `
-\u{1F6D1} Stopped: the same tool error repeated ${REPEAT_STALL_LIMIT} rounds in a row, so the agent was looping without making progress. The recurring error was:
-${stalledRepeatError}
-Fix that underlying cause (or grant the needed permission) and send "continue".
-` : `
-\u{1F6D1} Stopped: the last ${STALL_LIMIT} tool rounds all failed, so the agent looked stuck. Fix the underlying error (or grant the needed permission) and send "continue".
-`);
-          } else if (iteration >= budget) {
-            (options.onNotice ?? options.onText)(`
-\u23F8\uFE0F Stopped at the ${budget}-step safety limit \u2014 the task may be incomplete. Send "continue" to resume, or raise the limit via "maxIterations" in .nexrall/settings.json (or the NEXRALL_MAX_ITERATIONS env var). Auto-continue can be disabled with "autoContinue": false.
-`);
-          }
-        }
+        if (stopReason === "unknown" && iteration >= budget)
+          stopReason = "budget";
+        if (options.abortSignal?.aborted)
+          stopReason = "aborted";
+        const notice = stopReasonNotice(stopReason, { budget, repeatError: stalledRepeatError });
+        if (notice)
+          (options.onNotice ?? options.onText)(notice);
       } catch (err) {
         if (err instanceof types_1.AgentTurnError)
           throw err;
@@ -64004,7 +64214,7 @@ var InkReadlineAdapter = class extends EventEmitter3 {
 };
 
 // src/commands/chat.ts
-var CLI_VERSION = "0.5.52";
+var CLI_VERSION = "0.5.54";
 var MODEL_LABELS = {
   turbo: "Nexrall Turbo",
   pro: "Nexrall Pro",
@@ -65671,7 +65881,7 @@ function pluginSourceRemoveCommand(name, opts) {
 
 // src/index.ts
 var program2 = new Command();
-program2.name("nex").description("Nexrall Code \u2014 AI coding assistant (powered by Nexrall)").version("0.5.52").enablePositionalOptions();
+program2.name("nex").description("Nexrall Code \u2014 AI coding assistant (powered by Nexrall)").version("0.5.54").enablePositionalOptions();
 program2.command("auth").description("Login to your Nexrall account").action(authCommand);
 program2.command("logout").description("Log out of your Nexrall account").action(logoutCommand);
 program2.command("update").description("Update nex to the latest version").option("-c, --check", "Check for updates without installing").option("-y, --yes", "Skip confirmation prompt").action(async (opts) => {

package/package.json

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