nexrall-code 0.5.54 → 0.5.56

package/dist/index.js

@@ -14718,6 +14718,29 @@ var require_agentTypes = __commonJS({
       "notebook_edit"
     ];
     var BUILTIN_AGENTS = [
+      {
+        // The catch-all, matching Claude Code's `general-purpose`.
+        //
+        // This capability already existed — omitting `subagent_type` gives an unrestricted
+        // sub-agent — but it had no NAME, and that had two consequences worth fixing:
+        //
+        //   1. `permissions.deny: ["task(...)"]` matches on the agent name, so the ONE
+        //      sub-agent that can write files and run bash was the one variant a project
+        //      could not disable individually. Only a blanket `deny: ["task"]` reached it.
+        //   2. The model had to infer that leaving the field blank was even an option, so
+        //      it would sometimes pick a specialist that fitted badly (an unrestricted
+        //      explorer) rather than the general worker it actually wanted.
+        //
+        // `tools` is deliberately UNDEFINED, which means "no allowlist" — full access,
+        // inheriting whatever the session permits. That is the same power an unnamed
+        // sub-task always had; naming it changes only who can see and deny it. The safety
+        // properties elsewhere still apply: plan mode is inherited, the user's permission
+        // gate still runs on every call, and it cannot spawn further sub-agents.
+        name: "general-purpose",
+        description: "General-purpose worker for a multi-step task that needs BOTH exploration and changes (edit files, run commands) and that no specialist above fits. Inherits the session model and full tool access, so prefer a narrower agent when one matches.",
+        prompt: "You are a general-purpose engineering sub-agent. Work the task end to end: explore what you need, make the changes, and verify them with the project's own build/test commands.\n\nRules:\n- Mirror existing conventions; make the smallest correct change.\n- Verify before you claim success. If you could not verify, say so explicitly.\n- Your FINAL MESSAGE is the only thing that reaches the main agent: state what you changed (with file paths), what you ran and its outcome, and anything you deliberately left undone.",
+        source: "builtin"
+      },
       {
         name: "reviewer",
         description: "Read-only code reviewer \u2014 finds correctness bugs, edge cases, and security issues in a diff or file set. Cannot modify files.",
@@ -14780,6 +14803,9 @@ var require_agentTypes = __commonJS({
       // frontier model, and this is the agent most likely to be spawned in bulk.
       {
         name: "explorer",
+        // Lean prompt: this agent exists to keep bulk searching cheap, and it reports
+        // findings for the MAIN agent to interpret with full project context.
+        lightPrompt: true,
         description: "Fast read-only codebase explorer \u2014 locates files, symbols, and call sites and reports concise findings. Use to keep bulk searching out of the main context. Cannot modify files.",
         tools: READ_ONLY_TOOLS,
         model: "turbo",
@@ -15876,10 +15902,16 @@ var require_loop = __commonJS({
     exports.executeAgentMemoryWrite = executeAgentMemoryWrite;
     exports.stopReasonNotice = stopReasonNotice;
     exports.resolveMaxIterations = resolveMaxIterations;
+    exports.bashNeedsRepoLock = bashNeedsRepoLock;
+    exports.lockPathsFor = lockPathsFor;
+    exports.resolveMaxConcurrentSubtasks = resolveMaxConcurrentSubtasks;
     exports.createLimiter = createLimiter;
+    exports._resetSubTaskLimiter = _resetSubTaskLimiter;
+    exports.resolveSubtaskTimeoutMs = resolveSubtaskTimeoutMs;
     exports.extractSubTaskText = extractSubTaskText;
     exports.capSubTaskText = capSubTaskText;
     exports.summariseSubTaskProgress = summariseSubTaskProgress;
+    exports.lastToolResults = lastToolResults;
     exports.contextWindowFor = contextWindowFor2;
     exports.compactionThresholds = compactionThresholds2;
     exports.estimateBodyBytes = estimateBodyBytes2;
@@ -16116,10 +16148,89 @@ ${ctx.repeatError}
           _fileLocks.delete(absPath);
       }
     }
-    var MAX_CONCURRENT_SUBTASKS = (() => {
-      const raw = Number(process.env.NEXRALL_MAX_CONCURRENT_SUBTASKS);
-      return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 4;
-    })();
+    async function withFileLocks(absPaths, fn) {
+      const unique = [...new Set(absPaths.filter(Boolean))].sort();
+      if (unique.length === 0)
+        return fn();
+      const [first, ...rest] = unique;
+      return withFileLock(first, () => rest.length ? withFileLocks(rest, fn) : fn());
+    }
+    var WRITE_TOOLS = /* @__PURE__ */ new Set([
+      "write_file",
+      "edit_file",
+      "multi_edit",
+      "delete_file",
+      "move_file",
+      "copy_file",
+      "notebook_edit"
+    ]);
+    var REPO_STATE_LOCK = "\0repo-state";
+    var MUTATING_BASH_VERBS = /* @__PURE__ */ new Set([
+      "git",
+      "npm",
+      "pnpm",
+      "yarn",
+      "bun",
+      "cargo",
+      "go",
+      "pip",
+      "pip3",
+      "poetry",
+      "uv",
+      "bundle",
+      "composer",
+      "gradle",
+      "mvn",
+      "make",
+      "terraform",
+      "helm",
+      "docker",
+      "vsce",
+      "tsc",
+      "pytest",
+      "dotnet",
+      "swift",
+      "gem"
+    ]);
+    function bashNeedsRepoLock(command) {
+      if (!command)
+        return false;
+      const segments = command.split(/\|\||&&|[;|&\n()]|\$\(/);
+      for (const seg of segments) {
+        for (const tokenRaw of seg.trim().split(/\s+/)) {
+          const token = tokenRaw.replace(/^["']|["']$/g, "");
+          if (!token)
+            continue;
+          if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(token))
+            continue;
+          if (token === "sudo" || token === "time" || token === "nice" || token === "env")
+            continue;
+          const verb = token.split("/").pop() ?? token;
+          if (MUTATING_BASH_VERBS.has(verb))
+            return true;
+          break;
+        }
+      }
+      return false;
+    }
+    function lockPathsFor(name, input, workDir) {
+      if (!WRITE_TOOLS.has(name))
+        return [];
+      const raw = [input.path, input.source, input.destination, input.dest].filter((p) => typeof p === "string" && p.length > 0);
+      const abs = raw.map((p) => workDir ? path6.resolve(workDir, p) : p);
+      return abs.length ? abs : [name];
+    }
+    var DEFAULT_MAX_CONCURRENT_SUBTASKS = 4;
+    function resolveMaxConcurrentSubtasks(settingsRaw = {}) {
+      const clamp = (n) => Math.min(Math.floor(n), 16);
+      const fromEnv = Number(process.env.NEXRALL_MAX_CONCURRENT_SUBTASKS);
+      if (Number.isFinite(fromEnv) && fromEnv > 0)
+        return clamp(fromEnv);
+      const fromSettings = Number(settingsRaw.maxConcurrentSubtasks);
+      if (Number.isFinite(fromSettings) && fromSettings > 0)
+        return clamp(fromSettings);
+      return DEFAULT_MAX_CONCURRENT_SUBTASKS;
+    }
     function createLimiter(max) {
       let active = 0;
       const queue = [];
@@ -16138,7 +16249,20 @@ ${ctx.repeatError}
         }
       };
     }
-    var _subTaskLimit = createLimiter(MAX_CONCURRENT_SUBTASKS);
+    var _subTaskLimitInstance = null;
+    var _subTaskLimitMax = 0;
+    var _inFlightSubTasks = 0;
+    function subTaskLimiter(workDir) {
+      if (!_subTaskLimitInstance) {
+        _subTaskLimitMax = resolveMaxConcurrentSubtasks(workDir ? (0, rules_1.loadSettings)(workDir).raw : {});
+        _subTaskLimitInstance = createLimiter(_subTaskLimitMax);
+      }
+      return { run: _subTaskLimitInstance, max: _subTaskLimitMax };
+    }
+    function _resetSubTaskLimiter() {
+      _subTaskLimitInstance = null;
+      _subTaskLimitMax = 0;
+    }
     function humanDescription(name, input) {
       switch (name) {
         case "read_file":
@@ -16222,7 +16346,17 @@ ${ctx.repeatError}
     }
     var MAX_TASK_DEPTH = 1;
     var _subTaskCounter = 0;
-    var SUBTASK_TIMEOUT_MS = Number(process.env.NEXRALL_SUBTASK_TIMEOUT_MS) > 0 ? Number(process.env.NEXRALL_SUBTASK_TIMEOUT_MS) : 10 * 60 * 1e3;
+    var DEFAULT_SUBTASK_TIMEOUT_MS = 10 * 60 * 1e3;
+    function resolveSubtaskTimeoutMs(settingsRaw) {
+      const fromEnv = Number(process.env.NEXRALL_SUBTASK_TIMEOUT_MS);
+      if (Number.isFinite(fromEnv) && fromEnv > 0)
+        return Math.floor(fromEnv);
+      const raw = settingsRaw.subtaskTimeoutMs;
+      const fromSettings = Number(raw);
+      if (Number.isFinite(fromSettings) && fromSettings > 0)
+        return Math.floor(fromSettings);
+      return DEFAULT_SUBTASK_TIMEOUT_MS;
+    }
     var SUBTASK_MAX = 48e3;
     var ToolNotAllowedError = class extends Error {
       constructor(message) {
@@ -16279,11 +16413,59 @@ ${tail}`;
       }
       if (toolNames.length === 0)
         return "";
+      const recentFindings = lastToolResults(messages, SALVAGE_RESULT_COUNT, SALVAGE_RESULT_CHARS);
       const counts = /* @__PURE__ */ new Map();
       for (const n of toolNames)
         counts.set(n, (counts.get(n) ?? 0) + 1);
       const inventory = [...counts.entries()].sort((a, b) => b[1] - a[1]).map(([name, n]) => n > 1 ? `${name} \xD7${n}` : name).join(", ");
-      return `Tool calls completed before it was stopped (${toolNames.length} total): ${inventory}.`;
+      const header = `Tool calls completed before it was stopped (${toolNames.length} total): ${inventory}.`;
+      return recentFindings ? `${header}
+
+What its most recent tool calls actually returned (use this instead of repeating them):
+${recentFindings}` : header;
+    }
+    var SALVAGE_RESULT_COUNT = 4;
+    var SALVAGE_RESULT_CHARS = 2e3;
+    function lastToolResults(messages, count, maxChars) {
+      const nameById = /* @__PURE__ */ new Map();
+      for (const m2 of messages) {
+        if (m2.role !== "assistant" || !Array.isArray(m2.content))
+          continue;
+        for (const b of m2.content) {
+          if (b?.type === "tool_use" && b.id && typeof b.name === "string")
+            nameById.set(b.id, b.name);
+        }
+      }
+      const out = [];
+      for (let i2 = messages.length - 1; i2 >= 0 && out.length < count; i2--) {
+        const m2 = messages[i2];
+        if (m2.role !== "user" || !Array.isArray(m2.content))
+          continue;
+        for (const b of [...m2.content].reverse()) {
+          if (out.length >= count)
+            break;
+          if (b?.type !== "tool_result")
+            continue;
+          const text = toolResultText(b);
+          if (!text)
+            continue;
+          const name = nameById.get(String(b.tool_use_id ?? "")) ?? "tool";
+          const body = text.length > maxChars ? `${sliceSafeEnd(text, maxChars)}
+\u2026 [truncated]` : text;
+          out.push(`\u2022 ${name}:
+${body}`);
+        }
+      }
+      return out.reverse().join("\n\n");
+    }
+    function toolResultText(block) {
+      const c = block.content;
+      if (typeof c === "string")
+        return c.trim();
+      if (Array.isArray(c)) {
+        return c.filter((x2) => x2?.type === "text" && typeof x2.text === "string").map((x2) => x2.text).join("\n").trim();
+      }
+      return "";
     }
     async function runSubTask(input, options, agentTypes) {
       const prompt2 = typeof input.prompt === "string" ? input.prompt.trim() : "";
@@ -16324,16 +16506,17 @@ If you just created .nexrall/agents/` + requestedType + ".md, make sure the writ
       }
       const memoryScope = agent?.memory;
       const agentMemoryNotes = agent && memoryScope ? (0, memory_1.agentMemoryPreamble)(agent.name, memoryScope, options.workDir) : "";
+      const inheritedMd = agent?.lightPrompt ? "" : options.nexrallMd ?? "";
       const subNexrallMd = agent ? `# Sub-agent role: ${agent.name}
 ${agent.prompt}` + (agentMemoryNotes ? `
 
 ---
 
-${agentMemoryNotes}` : "") + (options.nexrallMd ? `
+${agentMemoryNotes}` : "") + (inheritedMd ? `
 
 ---
 
-${options.nexrallMd}` : "") : options.nexrallMd;
+${inheritedMd}` : "") : options.nexrallMd;
       const allowed = agent?.tools ? new Set(agent.tools) : null;
       if (allowed && memoryScope)
         allowed.add(exports.AGENT_MEMORY_TOOL);
@@ -16351,9 +16534,18 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
       };
       const subMessages = resumed ? [...resumed.messages, { role: "user", content: [{ type: "text", text: prompt2 }] }] : [{ role: "user", content: [{ type: "text", text: prompt2 }] }];
       const subAbort = { aborted: false };
-      const timer = setTimeout(() => {
-        subAbort.aborted = true;
-      }, SUBTASK_TIMEOUT_MS);
+      const subtaskTimeoutMs = resolveSubtaskTimeoutMs((0, rules_1.loadSettings)(options.workDir).raw);
+      let lastProgressAt = Date.now();
+      let stalled = false;
+      const bumpProgress = () => {
+        lastProgressAt = Date.now();
+      };
+      const stallWatchdog = setInterval(() => {
+        if (Date.now() - lastProgressAt > subtaskTimeoutMs) {
+          stalled = true;
+          subAbort.aborted = true;
+        }
+      }, 1e3);
       const parentAbortPoll = setInterval(() => {
         if (options.abortSignal?.aborted)
           subAbort.aborted = true;
@@ -16364,11 +16556,27 @@ ${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 } } : {},
+          // ── Assigned UNCONDITIONALLY, never by conditional spread ────────────────
+          //
+          // These two were previously spread in only when set:
+          //
+          //   ...(agent && memoryScope ? { _agentMemory: … } : {}),
+          //
+          // which does NOT clear the key — it leaves whatever `...options` already had.
+          // So a child WITHOUT its own `memory:` inherited its PARENT's binding and would
+          // have appended to another agent's private notes; likewise an agent with no
+          // `tools:` line inherited the parent's allowlist, making the prompt's capability
+          // claim disagree with its real one.
+          //
+          // MAX_TASK_DEPTH === 1 means no nested spawn can reach this today, so it is
+          // latent rather than live — but the limiter comment below explicitly contemplates
+          // raising that depth, and this is exactly the kind of leak that would come back
+          // as a security bug rather than a visible error. Explicit undefined makes the
+          // child's identity independent of the parent's by construction.
+          _agentMemory: agent && memoryScope ? { agentName: agent.name, scope: memoryScope } : void 0,
           // 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 } : {},
+          _allowedTools: allowed ?? void 0,
           editorContext: null,
           // fresh isolated context for sub-agent
           model: agent?.model ?? options.model,
@@ -16400,25 +16608,48 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
           // 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).
-          onToolUse: (n, i2) => options.onToolUse(n, i2, true),
-          onToolResult: (n, r2) => options.onToolResult(n, r2, true),
+          // Every tool event is PROGRESS: it proves the sub-agent is still doing work, which
+          // is what the stall watchdog above measures. Bumping on both use and result means a
+          // single very slow tool (a long test run) resets the clock when it starts AND when
+          // it finishes, so it cannot be mistaken for a hang.
+          onToolUse: (n, i2) => {
+            bumpProgress();
+            options.onToolUse(n, i2, true);
+          },
+          onToolResult: (n, r2) => {
+            bumpProgress();
+            options.onToolResult(n, r2, true);
+          },
           onToolStreamChunk: (n, c) => options.onToolStreamChunk?.(n, c, true),
           // Forward thinking so the UI shows the indicator while sub-agent reasons
-          onThinking: (text2) => options.onThinking?.(text2),
-          onThinkingDelta: (text2) => options.onThinkingDelta?.(text2),
-          onThinkingProgress: (tok) => options.onThinkingProgress?.(tok)
+          // Thinking is progress too — a model reasoning for minutes on a hard problem is
+          // working, not stalled. Without this, deep reasoning on an expensive tier would
+          // trip the watchdog precisely when the sub-agent was most valuable.
+          onThinking: (text2) => {
+            bumpProgress();
+            options.onThinking?.(text2);
+          },
+          onThinkingDelta: (text2) => {
+            bumpProgress();
+            options.onThinkingDelta?.(text2);
+          },
+          onThinkingProgress: (tok) => {
+            bumpProgress();
+            options.onThinkingProgress?.(tok);
+          }
         });
-        if (subAbort.aborted && !options.abortSignal?.aborted) {
-          const mins = Math.round(SUBTASK_TIMEOUT_MS / 6e4);
+        if (stalled && !options.abortSignal?.aborted) {
+          const mins = Math.round(subtaskTimeoutMs / 6e4);
           const partial = capSubTaskText(extractSubTaskText(result, false));
           const progress = summariseSubTaskProgress(result);
+          const partialId = (0, agentRegistry_1.rememberAgent)(agent?.name ?? null, typeof input.description === "string" && input.description.trim() || prompt2.slice(0, 80), result);
           const sections = [
-            `Sub-task STOPPED after ${mins} minutes without completing \u2014 treat the following as PARTIAL, unverified work, not a finished answer.`,
+            `Sub-task STOPPED after ${mins} minutes with NO PROGRESS (it was not making tool calls or producing output) \u2014 treat everything below as PARTIAL, unverified work, not a finished answer.`,
             progress,
             partial ? `Partial output before it was stopped:
 
 ${partial}` : "",
-            "Do NOT simply re-run the same sub-task: build on what is above, or split the remaining work into smaller, more focused sub-tasks."
+            `Do NOT re-run the same sub-task from scratch. Either build on what is above, or continue THIS run with resume_agent_id="${partialId}" (it still has everything it read), or split the remaining work into smaller, more focused sub-tasks.`
           ].filter(Boolean);
           return { error: sections.join("\n\n") };
         }
@@ -16447,7 +16678,7 @@ ${partial}` : "",
         }
         return { error: `Sub-task failed: ${err.message}` };
       } finally {
-        clearTimeout(timer);
+        clearInterval(stallWatchdog);
         clearInterval(parentAbortPoll);
       }
     }
@@ -17120,7 +17351,20 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
             if (!permitted) {
               result = { error: deniedReason ?? "Permission denied by user" };
             } else if (name === "task") {
-              result = depth === 0 ? await _subTaskLimit(() => runSubTask(input, options, agentTypes)) : await runSubTask(input, options, agentTypes);
+              if (depth === 0) {
+                const { run: limitRun, max: limitMax } = subTaskLimiter(options.workDir);
+                if (_inFlightSubTasks >= limitMax) {
+                  (options.onNotice ?? options.onText)(`\u23F3 Queued: ${limitMax} sub-agents are already running, so this one starts when a slot frees up (raise "maxConcurrentSubtasks" in .nexrall/settings.json to widen it).`);
+                }
+                _inFlightSubTasks++;
+                try {
+                  result = await limitRun(() => runSubTask(input, options, agentTypes));
+                } finally {
+                  _inFlightSubTasks--;
+                }
+              } else {
+                result = await runSubTask(input, options, agentTypes);
+              }
             } else {
               const pre = runToolHooks(hooks.PreToolUse, "PreToolUse", name, input, options.workDir);
               if (pre.block) {
@@ -17140,15 +17384,10 @@ ${options.nexrallMd}` : "") : options.nexrallMd;
                     result = { output: mcpOutput ?? "" };
                   } else {
                     options.checkpointManager?.recordBeforeMutation(name, input);
-                    const WRITE_TOOLS = /* @__PURE__ */ new Set(["write_file", "edit_file", "multi_edit", "delete_file", "move_file", "copy_file", "notebook_edit"]);
                     const onStream = options.onToolStreamChunk ? (chunk) => options.onToolStreamChunk(name, chunk) : void 0;
-                    if (WRITE_TOOLS.has(name)) {
-                      const targetPath = typeof input.path === "string" ? input.path : typeof input.source === "string" ? input.source : "";
-                      const absTarget = targetPath && options.workDir ? path6.resolve(options.workDir, targetPath) : targetPath;
-                      result = await withFileLock(absTarget || name, () => (0, executor_1.executeTool)(name, input, options.abortSignal, sandboxCfg, options.workDir, agentScope, onStream));
-                    } else {
-                      result = await (0, executor_1.executeTool)(name, input, options.abortSignal, sandboxCfg, options.workDir, agentScope, onStream);
-                    }
+                    const run = () => (0, executor_1.executeTool)(name, input, options.abortSignal, sandboxCfg, options.workDir, agentScope, onStream);
+                    const locks = name === "bash" ? bashNeedsRepoLock(String(input.command ?? "")) ? [REPO_STATE_LOCK] : [] : lockPathsFor(name, input, options.workDir);
+                    result = locks.length ? await withFileLocks(locks, run) : await run();
                   }
                 } catch (err) {
                   result = { error: `Tool execution failed: ${err.message}` };
@@ -54573,22 +54812,30 @@ var _replInterface = null;
 function setReadlineInterface(rl) {
   _replInterface = rl;
 }
+var _promptChain = Promise.resolve();
+function serialisePrompt(fn) {
+  const next = _promptChain.then(fn, fn);
+  _promptChain = next.catch(() => void 0);
+  return next;
+}
 function askUser(question) {
-  if (_replInterface) {
-    const rl = _replInterface;
+  return serialisePrompt(() => {
+    if (_replInterface) {
+      const rl = _replInterface;
+      return new Promise((resolve3) => {
+        rl.question(question, (answer) => resolve3(answer.trim()));
+      });
+    }
     return new Promise((resolve3) => {
-      rl.question(question, (answer) => resolve3(answer.trim()));
-    });
-  }
-  return new Promise((resolve3) => {
-    const rl = readline2.createInterface({
-      input: process.stdin,
-      output: process.stderr,
-      terminal: true
-    });
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve3(answer.trim());
+      const rl = readline2.createInterface({
+        input: process.stdin,
+        output: process.stderr,
+        terminal: true
+      });
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve3(answer.trim());
+      });
     });
   });
 }
@@ -64214,7 +64461,7 @@ var InkReadlineAdapter = class extends EventEmitter3 {
 };
 
 // src/commands/chat.ts
-var CLI_VERSION = "0.5.54";
+var CLI_VERSION = "0.5.56";
 var MODEL_LABELS = {
   turbo: "Nexrall Turbo",
   pro: "Nexrall Pro",
@@ -65881,7 +66128,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.54").enablePositionalOptions();
+program2.name("nex").description("Nexrall Code \u2014 AI coding assistant (powered by Nexrall)").version("0.5.56").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.54",
+  "version": "0.5.56",
   "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.29"
+    "@nexrall/code-core": "1.4.31"
   },
   "devDependencies": {
     "@aws-sdk/client-s3": "^3.600.0",