nexrall-code 0.5.54 → 0.5.55

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",
@@ -15877,9 +15903,11 @@ var require_loop = __commonJS({
     exports.stopReasonNotice = stopReasonNotice;
     exports.resolveMaxIterations = resolveMaxIterations;
     exports.createLimiter = createLimiter;
+    exports.resolveSubtaskTimeoutMs = resolveSubtaskTimeoutMs;
     exports.extractSubTaskText = extractSubTaskText;
     exports.capSubTaskText = capSubTaskText;
     exports.summariseSubTaskProgress = summariseSubTaskProgress;
+    exports.lastToolResults = lastToolResults;
     exports.contextWindowFor = contextWindowFor2;
     exports.compactionThresholds = compactionThresholds2;
     exports.estimateBodyBytes = estimateBodyBytes2;
@@ -16222,7 +16250,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 +16317,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 +16410,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 +16438,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 +16460,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 +16512,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 +16582,7 @@ ${partial}` : "",
         }
         return { error: `Sub-task failed: ${err.message}` };
       } finally {
-        clearTimeout(timer);
+        clearInterval(stallWatchdog);
         clearInterval(parentAbortPoll);
       }
     }
@@ -64214,7 +64349,7 @@ var InkReadlineAdapter = class extends EventEmitter3 {
 };
 
 // src/commands/chat.ts
-var CLI_VERSION = "0.5.54";
+var CLI_VERSION = "0.5.55";
 var MODEL_LABELS = {
   turbo: "Nexrall Turbo",
   pro: "Nexrall Pro",
@@ -65881,7 +66016,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.55").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.55",
   "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.30"
   },
   "devDependencies": {
     "@aws-sdk/client-s3": "^3.600.0",