@nexrall/code-core 1.4.31 → 1.4.33

package/dist/agent/agentTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agentTypes.d.ts","sourceRoot":"","sources":["../../src/agent/agentTypes.ts"],"names":[],"mappings":"AAiCA,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,OAAO,CAAC;IAClC,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;IACpD;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,qDAAqD;AACrD,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC;AA4U5D;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAyKD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,CAE3D;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,SAAS,EAAE,CAAC;IAAC,QAAQ,EAAE,YAAY,EAAE,CAAA;CAAE,CAqB5G;AAED,yFAAyF;AACzF,wBAAgB,cAAc,IAAI,MAAM,EAAE,CAEzC;AAED,2FAA2F;AAC3F,wBAAgB,aAAa,IAAI,SAAS,EAAE,CAE3C;AACD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,MAAM,CAY1D;AAQD,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAIjG"}
+{"version":3,"file":"agentTypes.d.ts","sourceRoot":"","sources":["../../src/agent/agentTypes.ts"],"names":[],"mappings":"AAiCA,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,iDAAiD;IACjD,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,OAAO,CAAC;IAClC,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;IACpD;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,qDAAqD;AACrD,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC;AA4U5D;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAoLD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,CAE3D;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,SAAS,EAAE,CAAC;IAAC,QAAQ,EAAE,YAAY,EAAE,CAAA;CAAE,CAqB5G;AAED,yFAAyF;AACzF,wBAAgB,cAAc,IAAI,MAAM,EAAE,CAEzC;AAED,2FAA2F;AAC3F,wBAAgB,aAAa,IAAI,SAAS,EAAE,CAE3C;AACD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,MAAM,CAY1D;AAQD,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAIjG"}

package/dist/agent/agentTypes.js

@@ -478,6 +478,17 @@ function loadDir(dir, source, into, warnings) {
                     message: `lists unknown tool name(s): ${unknown.join(', ')}. An allowlist only grants, so these silently do nothing and the agent cannot use them. Tool names are lower_snake_case (read_file, search_files, glob, bash).`,
                 });
             }
+            // `task` is a VALID tool name (the main agent has it), which is exactly why it
+            // needs its own warning rather than falling under the typo check above: listing it
+            // looks like it works and grants nothing. Nesting is capped by MAX_TASK_DEPTH, so
+            // sub-agents are never sent the tool at all.
+            if ((tools ?? []).includes('task')) {
+                warnings.push({
+                    file: full,
+                    agent: name,
+                    message: 'lists `task`, which cannot be granted: sub-agents are never sent that tool because they cannot spawn further sub-agents. Remove it — delegation stays with the main agent.',
+                });
+            }
             const strayKeys = Object.keys(meta).filter((k) => !KNOWN_META_KEYS.has(k));
             if (strayKeys.length) {
                 warnings.push({

package/dist/agent/loop.d.ts

@@ -1,5 +1,7 @@
 import type { Message, ToolResult, AgentLoopOptions, EnvContext } from '../types';
 import { type AgentMemoryScope } from './agentTypes';
+import { bashNeedsRepoLock } from '../permissions/bashClassify';
+export { bashNeedsRepoLock };
 /**
  * Fingerprint one round's tool failures, for the repeated-failure runaway guard.
  *
@@ -85,17 +87,6 @@ export declare function stopReasonNotice(reason: StopReason, ctx?: {
     repeatError?: string | null;
 }): string | null;
 export declare function resolveMaxIterations(optionValue: number | undefined, settingsRaw: Record<string, unknown>): number;
-/**
- * Whether a bash command should take the repo-state lock.
- *
- * Exported for tests: the failure mode (two concurrent `git commit`) is timing-dependent
- * and painful to reproduce through the real loop.
- *
- * Scans EVERY segment, not just the first word, because the mutating verb is routinely
- * not leading: `cd packages/core && npm publish`, `FOO=1 git push`, `ls && git commit`.
- * Checking only the first token would miss most real commands.
- */
-export declare function bashNeedsRepoLock(command: string): boolean;
 /**
  * Every path a tool call will touch, so all of them can be locked.
  *
@@ -125,6 +116,21 @@ export declare function resolveMaxConcurrentSubtasks(settingsRaw?: Record<string
 export declare function createLimiter(max: number): <T>(fn: () => Promise<T>) => Promise<T>;
 /** Test-only: forget the memoised limiter so a new limit can take effect. */
 export declare function _resetSubTaskLimiter(): void;
+export declare const NO_NESTED_SUBAGENTS_MSG: string;
+/**
+ * Whether a run at `depth` may spawn sub-agents.
+ *
+ * The single source of truth for THREE things that must agree: the `<available_subagents>`
+ * catalogue in the system prompt, whether the backend is asked to send the `task` tool
+ * schema at all, and which prompt block teaches delegation. They used to be decided
+ * independently, and the result was a sub-agent that got the tool plus instructions to use
+ * it but no catalogue — then a permission-gate refusal telling it not to ask for approval.
+ *
+ * `depth < MAX_TASK_DEPTH` mirrors runSubTask's own guard (which refuses at
+ * `depth >= MAX_TASK_DEPTH`), because the children this run would create land at
+ * `depth + 1`. Pure and exported so raising MAX_TASK_DEPTH is one edit, not four.
+ */
+export declare function canSpawnSubAgents(depth: number, allowedTools?: Set<string>): boolean;
 /**
  * How long a sub-agent may make NO progress before it is stopped.
  *

package/dist/agent/loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"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"}

package/dist/agent/loop.js

@@ -33,16 +33,16 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERIFY_CMD_RE = exports.WRITE_TOOL_NAMES = exports.ToolNotAllowedError = exports.AGENT_MEMORY_TOOL_SCHEMA = exports.AGENT_MEMORY_TOOL = exports._stallLimits = void 0;
+exports.VERIFY_CMD_RE = exports.WRITE_TOOL_NAMES = exports.ToolNotAllowedError = exports.NO_NESTED_SUBAGENTS_MSG = exports.AGENT_MEMORY_TOOL_SCHEMA = exports.AGENT_MEMORY_TOOL = exports._stallLimits = exports.bashNeedsRepoLock = void 0;
 exports.errorRoundSignature = errorRoundSignature;
 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.canSpawnSubAgents = canSpawnSubAgents;
 exports.resolveSubtaskTimeoutMs = resolveSubtaskTimeoutMs;
 exports.extractSubTaskText = extractSubTaskText;
 exports.capSubTaskText = capSubTaskText;
@@ -68,6 +68,11 @@ const executor_1 = require("../tools/executor");
 const agentTypes_1 = require("./agentTypes");
 const skills_1 = require("./skills");
 const rules_1 = require("../permissions/rules");
+// bashNeedsRepoLock lives in permissions/bashClassify.ts, not here: the permission
+// gate needs the same "does this command mutate shared state?" answer, and importing
+// it from loop.ts would make permissions depend on the agent loop (a cycle).
+const bashClassify_1 = require("../permissions/bashClassify");
+Object.defineProperty(exports, "bashNeedsRepoLock", { enumerable: true, get: function () { return bashClassify_1.bashNeedsRepoLock; } });
 const planMode_1 = require("./planMode");
 const agentRegistry_1 = require("./agentRegistry");
 const sandbox_1 = require("../tools/sandbox");
@@ -422,62 +427,6 @@ const WRITE_TOOLS = new Set([
  * they serialise against each other while everything else stays parallel.
  */
 const REPO_STATE_LOCK = '\u0000repo-state';
-/**
- * Commands that must not run concurrently with another instance of themselves.
- *
- * `bash` was excluded from the write-tool lock entirely, which was the largest hole in
- * the concurrency story: it is the most mutating tool there is, and with 4 sub-agents
- * fanned out two of them could run `git commit` simultaneously (one dies on
- * `.git/index.lock`), or two `npm install` (corrupted node_modules / lockfile), or two
- * `npm test` writing the same coverage and snapshot files (wrong results, not an error).
- * The comment above withFileLock explains carefully why two edit_file calls must be
- * sequenced, then a `bash -c 'echo x > file'` did exactly that with nothing holding it.
- *
- * Deliberately a VERB ALLOWLIST rather than serialising all of bash: an explorer's
- * `grep`/`rg`/`ls`/`cat` are read-only and are precisely the calls that benefit most
- * from running in parallel. Serialising those would trade a real correctness bug for a
- * real performance regression. These verbs are the ones that take a global lock, write
- * a lockfile, or mutate a shared build/dependency directory.
- */
-const MUTATING_BASH_VERBS = 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',
-]);
-/**
- * Whether a bash command should take the repo-state lock.
- *
- * Exported for tests: the failure mode (two concurrent `git commit`) is timing-dependent
- * and painful to reproduce through the real loop.
- *
- * Scans EVERY segment, not just the first word, because the mutating verb is routinely
- * not leading: `cd packages/core && npm publish`, `FOO=1 git push`, `ls && git commit`.
- * Checking only the first token would miss most real commands.
- */
-function bashNeedsRepoLock(command) {
-    if (!command)
-        return false;
-    // Split on shell separators, then take the first bare word of each segment, skipping
-    // env-var assignments (FOO=bar git push) and `sudo`/`time`-style prefixes.
-    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; // env assignment
-            if (token === 'sudo' || token === 'time' || token === 'nice' || token === 'env')
-                continue;
-            // Use the basename so `/usr/bin/git` and `./node_modules/.bin/tsc` still match.
-            const verb = token.split('/').pop() ?? token;
-            if (MUTATING_BASH_VERBS.has(verb))
-                return true;
-            break; // only the command word of each segment matters
-        }
-    }
-    return false;
-}
 /**
  * Every path a tool call will touch, so all of them can be locked.
  *
@@ -681,6 +630,37 @@ function humanDescription(name, input) {
 // sub-agents", and quietly making the worst-case fan-out quadratic. The value and
 // the documented behaviour now agree.
 const MAX_TASK_DEPTH = 1;
+// The ONE explanation for "you cannot spawn a sub-agent", shared by both places that
+// can refuse it: the permission gate (an allowlist without `task`) and the depth guard
+// inside runSubTask (a general-purpose sub-task, whose `allowed` set is null, reaches
+// that instead). The same impossibility used to produce two different messages, and the
+// allowlist one framed it as "a restriction of the agent definition" that "needs a
+// different agent" — sending the model off to look for an agent that can nest, when none
+// can. Nesting is structural, so say that once and say it the same way.
+exports.NO_NESTED_SUBAGENTS_MSG = 'Sub-agents cannot spawn further sub-agents — this is a structural limit, not a ' +
+    'permission, so no other agent type and no approval can lift it. Do this work directly ' +
+    'with the tools you have, or report back so the main agent can delegate it.';
+/**
+ * Whether a run at `depth` may spawn sub-agents.
+ *
+ * The single source of truth for THREE things that must agree: the `<available_subagents>`
+ * catalogue in the system prompt, whether the backend is asked to send the `task` tool
+ * schema at all, and which prompt block teaches delegation. They used to be decided
+ * independently, and the result was a sub-agent that got the tool plus instructions to use
+ * it but no catalogue — then a permission-gate refusal telling it not to ask for approval.
+ *
+ * `depth < MAX_TASK_DEPTH` mirrors runSubTask's own guard (which refuses at
+ * `depth >= MAX_TASK_DEPTH`), because the children this run would create land at
+ * `depth + 1`. Pure and exported so raising MAX_TASK_DEPTH is one edit, not four.
+ */
+function canSpawnSubAgents(depth, allowedTools) {
+    if (depth >= MAX_TASK_DEPTH)
+        return false;
+    // An allowlist that omits `task` is the other reason a run cannot delegate. No
+    // allowlist at all (the main agent, or a general-purpose sub-task) means no
+    // restriction from this clause — the depth check above still applies.
+    return allowedTools ? allowedTools.has('task') : true;
+}
 let _subTaskCounter = 0; // unique per-process id → per-sub-agent todo scope
 // A sub-agent that stalls (hung tool, model provider stuck, infinite tool-call
 // loop bypassing the iteration budget somehow) used to have NO ceiling of its
@@ -906,7 +886,7 @@ async function runSubTask(input, options, agentTypes) {
         return { error: 'task tool requires a non-empty prompt' };
     const depth = options._depth ?? 0;
     if (depth >= MAX_TASK_DEPTH) {
-        return { error: 'Sub-agents cannot spawn further sub-agents. Do this work directly, or report back so the main agent can delegate it.' };
+        return { error: exports.NO_NESTED_SUBAGENTS_MSG };
     }
     // Resolve an optional custom agent type (subagent_type).
     //
@@ -1025,6 +1005,21 @@ async function runSubTask(input, options, agentTypes) {
                 '`memory:` scope (project, user or local). Report anything worth remembering in your final ' +
                 'message instead — the main agent decides what to persist.');
         }
+        // `task` is not an allowlist matter — it is the depth ceiling, so it is refused here
+        // unconditionally rather than via `allowed`. gatedPermission is only ever built inside
+        // runSubTask, so every run it governs is already at depth >= 1 and can never spawn.
+        //
+        // Checking the allowlist instead left a gap: a hand-written `tools: read_file, task`
+        // made the name PRESENT, so neither this branch nor the allowlist branch below fired,
+        // and the call was permitted here only to be refused one frame deeper by runSubTask's
+        // depth guard. Same outcome, but the invariant stopped being local. Refusing on the
+        // tool name keeps it local and cannot be re-opened by an agent file.
+        //
+        // The generic allowlist text is also wrong for this case: it says "report back that
+        // the task needs a different agent", pointing at an escape hatch that cannot exist.
+        if (req.tool === 'task') {
+            throw new ToolNotAllowedError(exports.NO_NESTED_SUBAGENTS_MSG);
+        }
         if (allowed && !allowed.has(req.tool)) {
             throw new ToolNotAllowedError(`The "${agent.name}" sub-agent is not allowed to use \`${req.tool}\` — it is not in that agent's ` +
                 'tool allowlist. This is a restriction of the agent definition, NOT a user decision: do not ask ' +
@@ -1953,7 +1948,10 @@ async function runAgentLoop(initialMessages, options) {
     // error path would name it again. Enforcement still happens at dispatch
     // (runSubTask) — this is the cosmetic half; that is the load-bearing half.
     const agentTypes = (0, agentTypes_1.loadAgentTypes)(options.workDir).filter((t) => (0, rules_1.evaluatePermission)(settings.permissions, 'task', { subagent_type: t.name }, options.workDir) !== 'deny');
-    const agentsCatalogue = depth === 0 ? (0, agentTypes_1.summariseAgents)(agentTypes) : '';
+    // Can THIS run delegate at all? Previously only the catalogue was gated (`depth === 0`)
+    // while the tool schema and its instructions went to every run — see canSpawnSubAgents.
+    const maySpawn = canSpawnSubAgents(depth, options._allowedTools);
+    const agentsCatalogue = maySpawn ? (0, agentTypes_1.summariseAgents)(agentTypes) : '';
     // Skills catalogue — unlike agentsCatalogue, available at every depth: a skill is
     // just a reusable prompt template (via use_skill), not another spawn point, so
     // sub-agents benefit from the same playbooks without the recursion concerns that
@@ -2276,6 +2274,9 @@ async function runAgentLoop(initialMessages, options) {
                         ? options._allowedTools.has('memory_write')
                         : true, // no allowlist = main agent = may write
                     hasOwnAgentStore: !!options._agentMemory,
+                    // Withholds the `task` schema and its instructions when this run cannot
+                    // delegate — see canSpawnSubAgents.
+                    canSpawnSubAgents: maySpawn,
                     agents: agentsCatalogue || undefined,
                     skills: skillsCatalogue || undefined,
                     // Only allow a post-render restart when the caller actually implements the
@@ -2650,7 +2651,7 @@ async function runAgentLoop(initialMessages, options) {
                                 // This matters far more with sub-agents than without: up to 4 run
                                 // concurrently, each issuing its own tool calls into this same process.
                                 const locks = name === 'bash'
-                                    ? (bashNeedsRepoLock(String(input.command ?? '')) ? [REPO_STATE_LOCK] : [])
+                                    ? ((0, bashClassify_1.bashNeedsRepoLock)(String(input.command ?? '')) ? [REPO_STATE_LOCK] : [])
                                     : lockPathsFor(name, input, options.workDir);
                                 result = locks.length ? await withFileLocks(locks, run) : await run();
                             }

package/dist/api/client.d.ts

@@ -55,6 +55,17 @@ export interface StreamChatOptions {
     canWriteSharedMemory?: boolean;
     /** Whether this run is a sub-agent with its own `memory:` store (agent_memory_write). */
     hasOwnAgentStore?: boolean;
+    /**
+     * Whether THIS run may spawn sub-agents, i.e. whether the backend should send the
+     * `task` tool schema and the prompt block that teaches it.
+     *
+     * Same rule as canWriteSharedMemory, applied to a worse case: `task` was in the
+     * backend's static catalogue, so every sub-agent SAW the tool and was told to use it,
+     * then got refused by its own allowlist at the permission gate. Withholding the schema
+     * is the fix — a tool the model cannot see is one it cannot try. Undefined means
+     * "main agent" (may spawn).
+     */
+    canSpawnSubAgents?: boolean;
     /**
      * Opt in to restarting a turn that died AFTER partial output was rendered.
      *

package/dist/api/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAA8B,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAiErH,eAAO,MAAM,QAAQ,QAAmB,CAAC;AAIzC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EAC5D,OAAO,EAAE,CAAC,EAAE,EACZ,UAAU,EAAE,KAAK,CAAC;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GACtD,CAAC,EAAE,CAeL;AAiGD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IACnC,oFAAoF;IACpF,UAAU,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IACjG,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6IAA6I;IAC7I,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,yFAAyF;IACzF,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;;;;;;;;;OAeG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAiDD,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,CAAC,CAAC,EAAE,QAAQ,KAAK,IAAI,GAC7B,OAAO,CAAC,OAAO,CAAC,CAwlClB;AAID;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAU9D;AAID;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAYxD;AAID,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CA0BlD;AAID,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA+B1E;AAID,wBAAsB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA0BhF"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/api/client.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAA8B,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAiErH,eAAO,MAAM,QAAQ,QAAmB,CAAC;AAIzC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EAC5D,OAAO,EAAE,CAAC,EAAE,EACZ,UAAU,EAAE,KAAK,CAAC;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GACtD,CAAC,EAAE,CAeL;AAiGD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,aAAa,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IACnC,oFAAoF;IACpF,UAAU,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IACjG,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6IAA6I;IAC7I,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,yFAAyF;IACzF,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;;;OASG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;;;;;;;;;;;;OAeG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAiDD,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,CAAC,CAAC,EAAE,QAAQ,KAAK,IAAI,GAC7B,OAAO,CAAC,OAAO,CAAC,CAwlClB;AAID;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAU9D;AAID;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAYxD;AAID,wBAAsB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CA0BlD;AAID,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA+B1E;AAID,wBAAsB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA0BhF"}

package/dist/api/client.js

@@ -243,7 +243,7 @@ function sleep(ms) {
  *  the nested product (36) exists to bound pathological cases, not to be reached. */
 const MAX_TOTAL_ATTEMPTS = (MAX_RETRIES + 1) * (MAX_RETRIES + 1);
 async function streamChat(messages, options, onEvent) {
-    const { model, env, editorContext, nexrallMd, mode, effort, clientType, abortSignal, extraTools, agents, skills, allowRestartAfterRender, canWriteSharedMemory, hasOwnAgentStore } = options;
+    const { model, env, editorContext, nexrallMd, mode, effort, clientType, abortSignal, extraTools, agents, skills, allowRestartAfterRender, canWriteSharedMemory, hasOwnAgentStore, canSpawnSubAgents } = options;
     // IDEMPOTENCY KEY for this logical turn, generated ONCE and reused by every retry
     // below (that reuse is the entire point — a fresh id per attempt would be useless).
     //
@@ -331,7 +331,7 @@ async function streamChat(messages, options, onEvent) {
             {
                 method: 'POST',
                 headers: authHeaders(),
-                body: JSON.stringify({ messages, model, env, editorContext, nexrallMd, mode, effort, clientType, extraTools, agents, skills, turnId, canWriteSharedMemory, hasOwnAgentStore }),
+                body: JSON.stringify({ messages, model, env, editorContext, nexrallMd, mode, effort, clientType, extraTools, agents, skills, turnId, canWriteSharedMemory, hasOwnAgentStore, canSpawnSubAgents }),
                 signal: controller.signal,
             },
         ];

package/dist/index.d.ts

@@ -20,6 +20,8 @@ export * from './agent/agentTypes';
 export * from './agent/planMode';
 export * from './agent/agentRegistry';
 export * from './permissions/rules';
+export * from './permissions/modePolicy';
+export * from './permissions/bashClassify';
 export * from './permissions/destructive';
 export * from './plugins/index';
 export * from './plugins/installer';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC"}

package/dist/index.js

@@ -36,6 +36,8 @@ __exportStar(require("./agent/agentTypes"), exports);
 __exportStar(require("./agent/planMode"), exports);
 __exportStar(require("./agent/agentRegistry"), exports);
 __exportStar(require("./permissions/rules"), exports);
+__exportStar(require("./permissions/modePolicy"), exports);
+__exportStar(require("./permissions/bashClassify"), exports);
 __exportStar(require("./permissions/destructive"), exports);
 __exportStar(require("./plugins/index"), exports);
 __exportStar(require("./plugins/installer"), exports);

package/dist/permissions/bashClassify.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Whether a bash command should take the repo-state lock.
+ *
+ * Exported for tests: the failure mode (two concurrent `git commit`) is timing-dependent
+ * and painful to reproduce through the real loop.
+ *
+ * Scans EVERY segment, not just the first word, because the mutating verb is routinely
+ * not leading: `cd packages/core && npm publish`, `FOO=1 git push`, `ls && git commit`.
+ * Checking only the first token would miss most real commands.
+ */
+export declare function bashNeedsRepoLock(command: string): boolean;
+//# sourceMappingURL=bashClassify.d.ts.map

package/dist/permissions/bashClassify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bashClassify.d.ts","sourceRoot":"","sources":["../../src/permissions/bashClassify.ts"],"names":[],"mappings":"AAqCA;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAkB1D"}

package/dist/permissions/bashClassify.js

@@ -0,0 +1,73 @@
+"use strict";
+// ─── Classifying shell commands ───────────────────────────────────────────────
+//
+// Lives in permissions/ rather than agent/loop.ts because TWO subsystems need the same
+// answer to "does this command mutate shared state?":
+//
+//   • the concurrency locks — two `git commit` must not interleave;
+//   • the permission gate — `auto` mode runs `npm test` without asking but must still
+//     prompt for anything with wider side effects.
+//
+// Keeping one classifier means those can never disagree. Two copies would be a second
+// source of truth that has to stay in sync forever, which is the exact class of bug this
+// codebase keeps turning up (a prompt promising what the gate didn't enforce; a mode the
+// gate never read).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bashNeedsRepoLock = bashNeedsRepoLock;
+/**
+ * Commands that must not run concurrently with another instance of themselves.
+ *
+ * `bash` was excluded from the write-tool lock entirely, which was the largest hole in
+ * the concurrency story: it is the most mutating tool there is, and with 4 sub-agents
+ * fanned out two of them could run `git commit` simultaneously (one dies on
+ * `.git/index.lock`), or two `npm install` (corrupted node_modules / lockfile), or two
+ * `npm test` writing the same coverage and snapshot files (wrong results, not an error).
+ * The comment above withFileLock explains carefully why two edit_file calls must be
+ * sequenced, then a `bash -c 'echo x > file'` did exactly that with nothing holding it.
+ *
+ * Deliberately a VERB ALLOWLIST rather than serialising all of bash: an explorer's
+ * `grep`/`rg`/`ls`/`cat` are read-only and are precisely the calls that benefit most
+ * from running in parallel. Serialising those would trade a real correctness bug for a
+ * real performance regression. These verbs are the ones that take a global lock, write
+ * a lockfile, or mutate a shared build/dependency directory.
+ */
+const MUTATING_BASH_VERBS = 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',
+]);
+/**
+ * Whether a bash command should take the repo-state lock.
+ *
+ * Exported for tests: the failure mode (two concurrent `git commit`) is timing-dependent
+ * and painful to reproduce through the real loop.
+ *
+ * Scans EVERY segment, not just the first word, because the mutating verb is routinely
+ * not leading: `cd packages/core && npm publish`, `FOO=1 git push`, `ls && git commit`.
+ * Checking only the first token would miss most real commands.
+ */
+function bashNeedsRepoLock(command) {
+    if (!command)
+        return false;
+    // Split on shell separators, then take the first bare word of each segment, skipping
+    // env-var assignments (FOO=bar git push) and `sudo`/`time`-style prefixes.
+    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; // env assignment
+            if (token === 'sudo' || token === 'time' || token === 'nice' || token === 'env')
+                continue;
+            // Use the basename so `/usr/bin/git` and `./node_modules/.bin/tsc` still match.
+            const verb = token.split('/').pop() ?? token;
+            if (MUTATING_BASH_VERBS.has(verb))
+                return true;
+            break; // only the command word of each segment matters
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=bashClassify.js.map

package/dist/permissions/modePolicy.d.ts

@@ -0,0 +1,55 @@
+/** Permission modes, in increasing order of autonomy. */
+export type PermissionMode = 'plan' | 'ask' | 'edit' | 'auto';
+/** What the gate should do with one tool call. */
+export type PolicyDecision = 'allow' | 'ask' | 'deny' | 'confirm';
+export interface PolicyInput {
+    tool: string;
+    input: Record<string, unknown>;
+    mode: PermissionMode;
+    /** True when the user has already opted into blanket approval (--yolo / bypass). */
+    bypass?: boolean;
+    /** True when this call is irreversible (DB drop, force-push, rm -rf …). */
+    destructive?: boolean;
+}
+/**
+ * Tools that only ever READ. Always allowed, in every mode including plan.
+ *
+ * Kept here rather than in each client so "read-only" cannot mean two different things
+ * in two windows. Note `memory_write` is NOT here even though the CLI's old list had it
+ * — it mutates durable cross-session state, and listing it under "read-only / safe"
+ * meant it silently bypassed plan mode's read-only guarantee.
+ */
+export declare const READ_ONLY_TOOLS: Set<string>;
+/** Tools that write to the filesystem. */
+export declare const FILE_WRITE_TOOLS: Set<string>;
+/** Tools that move/delete files — riskier than an in-place edit. */
+export declare const FILE_MUTATE_TOOLS: Set<string>;
+/** Tools that run a shell command. */
+export declare const BASH_TOOLS: Set<string>;
+/**
+ * Is this bash command read-only?
+ *
+ * Deliberately delegates to `bashNeedsRepoLock`, the classifier written for the
+ * concurrency work: it already distinguishes commands that mutate shared state
+ * (`git`, `npm`, `cargo`, `make` …) from ones that only read (`grep`, `ls`, `cat`,
+ * `rg`), scanning every shell segment so `cd x && npm publish` is caught.
+ *
+ * Reusing it is the point. Writing a second classifier here would create two
+ * definitions of "mutating" that must agree forever — the exact failure this whole
+ * audit keeps finding. If the lock treats a command as mutating, so does the gate.
+ */
+export declare function isReadOnlyBash(command: string): boolean;
+/**
+ * The single source of truth for "should we prompt?".
+ *
+ * Order matters and mirrors Claude Code's: destructive actions are checked BEFORE any
+ * blanket approval, so an irreversible command can never ride `--yolo` or `auto`
+ * straight to execution. That ordering has a body count in the industry (dropped
+ * production databases), and it is the one rule no convenience setting may override.
+ */
+export declare function decide(req: PolicyInput): PolicyDecision;
+/** Human-readable one-liner for the footer / status bar. */
+export declare function describeMode(mode: PermissionMode): string;
+/** Normalise arbitrary input to a known mode, defaulting to the safe middle. */
+export declare function parseMode(raw: unknown): PermissionMode;
+//# sourceMappingURL=modePolicy.d.ts.map

package/dist/permissions/modePolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modePolicy.d.ts","sourceRoot":"","sources":["../../src/permissions/modePolicy.ts"],"names":[],"mappings":"AAsBA,yDAAyD;AACzD,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAE9D,kDAAkD;AAClD,MAAM,MAAM,cAAc,GACtB,OAAO,GACP,KAAK,GACL,MAAM,GACN,SAAS,CAAC;AAEd,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,IAAI,EAAE,cAAc,CAAC;IACrB,oFAAoF;IACpF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,2EAA2E;IAC3E,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,aAU1B,CAAC;AAEH,0CAA0C;AAC1C,eAAO,MAAM,gBAAgB,aAE3B,CAAC;AAEH,oEAAoE;AACpE,eAAO,MAAM,iBAAiB,aAE5B,CAAC;AAEH,sCAAsC;AACtC,eAAO,MAAM,UAAU,aAAsD,CAAC;AAE9E;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,WAAW,GAAG,cAAc,CAmDvD;AAED,4DAA4D;AAC5D,wBAAgB,YAAY,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAOzD;AAED,gFAAgF;AAChF,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,cAAc,CAGtD"}

package/dist/permissions/modePolicy.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASH_TOOLS = exports.FILE_MUTATE_TOOLS = exports.FILE_WRITE_TOOLS = exports.READ_ONLY_TOOLS = void 0;
+exports.isReadOnlyBash = isReadOnlyBash;
+exports.decide = decide;
+exports.describeMode = describeMode;
+exports.parseMode = parseMode;
+const bashClassify_1 = require("./bashClassify");
+/**
+ * Tools that only ever READ. Always allowed, in every mode including plan.
+ *
+ * Kept here rather than in each client so "read-only" cannot mean two different things
+ * in two windows. Note `memory_write` is NOT here even though the CLI's old list had it
+ * — it mutates durable cross-session state, and listing it under "read-only / safe"
+ * meant it silently bypassed plan mode's read-only guarantee.
+ */
+exports.READ_ONLY_TOOLS = new Set([
+    'read_file', 'list_directory', 'search_files', 'glob', 'grep',
+    'fetch_url', 'web_search',
+    'bash_output', 'kill_shell',
+    'todo_read', 'todo_write',
+    'memory_read',
+    'use_skill',
+    'notebook_read',
+    'get_diagnostics', 'go_to_definition', 'find_references',
+    'get_symbols', 'get_workspace_symbols', 'get_hover',
+]);
+/** Tools that write to the filesystem. */
+exports.FILE_WRITE_TOOLS = new Set([
+    'write_file', 'create_file', 'edit_file', 'multi_edit', 'notebook_edit',
+]);
+/** Tools that move/delete files — riskier than an in-place edit. */
+exports.FILE_MUTATE_TOOLS = new Set([
+    'delete_file', 'move_file', 'copy_file',
+]);
+/** Tools that run a shell command. */
+exports.BASH_TOOLS = new Set(['bash', 'run_command', 'execute_command']);
+/**
+ * Is this bash command read-only?
+ *
+ * Deliberately delegates to `bashNeedsRepoLock`, the classifier written for the
+ * concurrency work: it already distinguishes commands that mutate shared state
+ * (`git`, `npm`, `cargo`, `make` …) from ones that only read (`grep`, `ls`, `cat`,
+ * `rg`), scanning every shell segment so `cd x && npm publish` is caught.
+ *
+ * Reusing it is the point. Writing a second classifier here would create two
+ * definitions of "mutating" that must agree forever — the exact failure this whole
+ * audit keeps finding. If the lock treats a command as mutating, so does the gate.
+ */
+function isReadOnlyBash(command) {
+    return !(0, bashClassify_1.bashNeedsRepoLock)(command);
+}
+/**
+ * The single source of truth for "should we prompt?".
+ *
+ * Order matters and mirrors Claude Code's: destructive actions are checked BEFORE any
+ * blanket approval, so an irreversible command can never ride `--yolo` or `auto`
+ * straight to execution. That ordering has a body count in the industry (dropped
+ * production databases), and it is the one rule no convenience setting may override.
+ */
+function decide(req) {
+    const { tool, mode } = req;
+    const command = String(req.input.command ?? req.input.cmd ?? '');
+    // 1. Reads are always fine — an agent that cannot read cannot help.
+    //    Checked before plan mode too: plan mode is read-ONLY, not read-nothing.
+    if (exports.READ_ONLY_TOOLS.has(tool))
+        return 'allow';
+    if (exports.BASH_TOOLS.has(tool) && isReadOnlyBash(command) && !req.destructive)
+        return 'allow';
+    // 2. Irreversible actions ALWAYS need an explicit human "yes".
+    //    Before bypass, before mode. `rm -rf`, `git push --force`, `DROP TABLE` are not
+    //    things any mode should silently perform, and the strong confirm treatment (type
+    //    the word "yes", no "approve all") is what makes it a real speed bump.
+    if (req.destructive)
+        return 'confirm';
+    // 3. Plan mode: refuse every remaining (i.e. mutating) tool outright.
+    //    A refusal, not a prompt — the guarantee is "nothing changes until I approve the
+    //    plan", and a prompt would let one distracted keypress break it.
+    if (mode === 'plan')
+        return 'deny';
+    // 4. Explicit blanket approval (--yolo / bypassPermissions). Deliberately after the
+    //    destructive check above.
+    if (req.bypass)
+        return 'allow';
+    // 5. Mode policy for the mutating tools that remain.
+    if (exports.FILE_WRITE_TOOLS.has(tool) || exports.FILE_MUTATE_TOOLS.has(tool)) {
+        // `edit` and `auto` both pre-authorise ordinary file edits — that is the whole
+        // reason to leave `ask`.
+        return mode === 'ask' ? 'ask' : 'allow';
+    }
+    if (exports.BASH_TOOLS.has(tool)) {
+        // A mutating-but-recoverable command: `npm test`, `npm install`, `git commit`,
+        // `cargo build`. `auto` runs these, which is the behaviour its own prompt block
+        // already advertises. `edit` still asks, matching Claude Code's acceptEdits —
+        // "file changes flow, anything with side effects beyond the working directory
+        // still prompts" — because shell commands reach the network, global caches and
+        // other checkouts, not just this repo.
+        return mode === 'auto' ? 'allow' : 'ask';
+    }
+    // 6. Anything unrecognised — a newly added tool, an MCP tool, a plugin tool — asks,
+    //    in EVERY mode including `auto`.
+    //
+    //    Fail-CLOSED on permission, deliberately: a tool nobody has classified must not
+    //    inherit autonomy merely because the user chose a permissive mode. An MCP server
+    //    is third-party code whose blast radius this policy cannot see, so `auto` meaning
+    //    "run anything, including things I've never heard of" would make the mode
+    //    unauditable. Same principle as forcing an unparseable agent definition to
+    //    read-only: the less we know, the less it gets.
+    return 'ask';
+}
+/** Human-readable one-liner for the footer / status bar. */
+function describeMode(mode) {
+    switch (mode) {
+        case 'plan': return 'plan — read-only, produces a plan for approval';
+        case 'ask': return 'ask — approves reads; asks before edits and commands';
+        case 'edit': return 'edit — edits files freely; asks before shell commands';
+        case 'auto': return 'auto — edits and runs commands; still confirms irreversible actions';
+    }
+}
+/** Normalise arbitrary input to a known mode, defaulting to the safe middle. */
+function parseMode(raw) {
+    const s = String(raw ?? '').trim().toLowerCase();
+    return s === 'plan' || s === 'ask' || s === 'edit' || s === 'auto' ? s : 'ask';
+}
+//# sourceMappingURL=modePolicy.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexrall/code-core",
-  "version": "1.4.31",
+  "version": "1.4.33",
   "description": "Core agent loop, tools, and extension primitives for Nexrall Code — embed an AI coding agent in any Node.js application.",
   "license": "MIT",
   "author": "Nexrall <support@nexrall.com> (https://nexrall.com)",