@nexrall/code-core 1.4.63 → 1.4.65

package/dist/agent/agentRegistry.d.ts

@@ -44,9 +44,17 @@ export interface StoredAgent {
     seq: number;
     /** Rough JSON size, cached so the byte cap doesn't re-serialise on every write. */
     bytes: number;
+    /**
+     * The conversation (AgentLoopOptions.sessionId) that created it. Every main agent's
+     * scope is 'root', so without this any chat in a shared process (VS Code panels,
+     * desktop tasks) could resume another chat's sub-agents.
+     */
+    sessionKey?: string;
 }
+export declare function enableAgentTranscriptPersistence(dir?: string): void;
+export declare function disableAgentTranscriptPersistence(): void;
 /** Store a finished sub-agent's transcript. Returns its resumable id. */
-export declare function rememberAgent(agentName: string | null, description: string, messages: Message[], ownerScope?: string): string;
+export declare function rememberAgent(agentName: string | null, description: string, messages: Message[], ownerScope?: string, sessionKey?: string): string;
 /**
  * May `scope` resume/modify the agent stored under `id`?
  *
@@ -55,10 +63,13 @@ export declare function rememberAgent(agentName: string | null, description: str
  * and inventing a prefix convention to fake it would be a second guessable capability.
  * The main agent is included because it owns the session and already sees every result.
  */
-export declare function canResume(stored: StoredAgent, scope: string): boolean;
+export declare function canResume(stored: StoredAgent, scope: string, sessionKey?: string): boolean;
 /** Append a resumed run's new messages to an existing agent. */
-export declare function updateAgent(id: string, messages: Message[], scope?: string): void;
+export declare function updateAgent(id: string, messages: Message[], scope?: string, sessionKey?: string): void;
 export declare function getAgent(id: string): StoredAgent | undefined;
+/** Mark an agent as being resumed. False if another run already holds it. */
+export declare function claimAgentForResume(id: string): boolean;
+export declare function releaseAgentForResume(id: string): void;
 /** Newest first — the order a "which agents can I resume?" list wants. */
 export declare function listAgents(): StoredAgent[];
 /** Test seam. Not exported through index.ts's public surface by intent. */

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

@@ -1 +1 @@
-{"version":3,"file":"agentRegistry.d.ts","sourceRoot":"","sources":["../../src/agent/agentRegistry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AA8CxC,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX;;;;;;OAMG;IACH,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB;;;;;;;;;;;;;;OAcG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB,2EAA2E;IAC3E,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,iFAAiF;IACjF,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;;;OASG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,mFAAmF;IACnF,KAAK,EAAE,MAAM,CAAC;CACf;AA4CD,yEAAyE;AACzE,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,OAAO,EAAE,EACnB,UAAU,SAAS,GAClB,MAAM,CAkBR;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAErE;AAED,gEAAgE;AAChE,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,KAAK,SAAS,GAAG,IAAI,CAgBjF;AAED,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAE5D;AAED,0EAA0E;AAC1E,wBAAgB,UAAU,IAAI,WAAW,EAAE,CAE1C;AAED,2EAA2E;AAC3E,wBAAgB,mBAAmB,IAAI,IAAI,CAI1C;AAED,eAAO,MAAM,OAAO;;;CAAkC,CAAC"}
+{"version":3,"file":"agentRegistry.d.ts","sourceRoot":"","sources":["../../src/agent/agentRegistry.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AA8CxC,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX;;;;;;OAMG;IACH,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB;;;;;;;;;;;;;;OAcG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB,2EAA2E;IAC3E,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,iFAAiF;IACjF,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;;;OASG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,mFAAmF;IACnF,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAsDD,wBAAgB,gCAAgC,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAInE;AAED,wBAAgB,iCAAiC,IAAI,IAAI,CAAwB;AAoCjF,yEAAyE;AACzE,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,OAAO,EAAE,EACnB,UAAU,SAAS,EACnB,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAoBR;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAG1F;AAED,gEAAgE;AAChE,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,KAAK,SAAS,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAiBtG;AAED,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAU5D;AAMD,6EAA6E;AAC7E,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAIvD;AACD,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAuB;AAE9E,0EAA0E;AAC1E,wBAAgB,UAAU,IAAI,WAAW,EAAE,CAE1C;AAED,2EAA2E;AAC3E,wBAAgB,mBAAmB,IAAI,IAAI,CAI1C;AAED,eAAO,MAAM,OAAO;;;CAAkC,CAAC"}

package/dist/agent/agentRegistry.js

@@ -1,13 +1,53 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._limits = void 0;
+exports.enableAgentTranscriptPersistence = enableAgentTranscriptPersistence;
+exports.disableAgentTranscriptPersistence = disableAgentTranscriptPersistence;
 exports.rememberAgent = rememberAgent;
 exports.canResume = canResume;
 exports.updateAgent = updateAgent;
 exports.getAgent = getAgent;
+exports.claimAgentForResume = claimAgentForResume;
+exports.releaseAgentForResume = releaseAgentForResume;
 exports.listAgents = listAgents;
 exports._resetAgentRegistry = _resetAgentRegistry;
 const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
 // ─── Resumable sub-agents ────────────────────────────────────────────────────
 //
 // A sub-agent normally starts with a blank slate: fresh context, no memory of a
@@ -91,8 +131,72 @@ function sizeOf(messages) {
         return MAX_TOTAL_BYTES;
     }
 }
+// ── Disk persistence (opt-in, per host) ─────────────────────────────────────────
+//
+// Claude Code keeps sub-agent transcripts on disk, so "continue that agent" survives a
+// restart. Hosts opt in with enableAgentTranscriptPersistence() at startup; library
+// callers and tests stay purely in-memory. Ids carry 32 random bits, so knowing one is
+// the capability (the model only ever learns ids from its own tool results).
+let _persistDir = null;
+const PERSIST_MAX_FILES = 100;
+const PERSIST_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1000;
+function enableAgentTranscriptPersistence(dir) {
+    _persistDir = dir ?? process.env.NEXRALL_AGENT_TRANSCRIPTS_DIR ?? path.join(os.homedir(), '.nexrall', 'agent-transcripts');
+    try {
+        fs.mkdirSync(_persistDir, { recursive: true, mode: 0o700 });
+    }
+    catch {
+        _persistDir = null;
+        return;
+    }
+    prunePersisted();
+}
+function disableAgentTranscriptPersistence() { _persistDir = null; }
+function persistedPath(id) {
+    if (!_persistDir || !/^agent_\d+_[0-9a-f]{8}$/.test(id))
+        return null;
+    return path.join(_persistDir, `${id}.json`);
+}
+function persist(agent) {
+    const p = persistedPath(agent.id);
+    if (!p)
+        return;
+    try {
+        fs.writeFileSync(p, JSON.stringify(agent), { mode: 0o600 });
+    }
+    catch { /* best effort */ }
+}
+function loadPersisted(id) {
+    const p = persistedPath(id);
+    if (!p)
+        return undefined;
+    try {
+        const a = JSON.parse(fs.readFileSync(p, 'utf-8'));
+        if (a?.id !== id || !Array.isArray(a.messages))
+            return undefined;
+        // A restarted process has fresh scope counters, so only the main agent ('root')
+        // may resume a transcript from a previous process.
+        return { ...a, ownerScope: 'root', seq: ++_seq };
+    }
+    catch {
+        return undefined;
+    }
+}
+function prunePersisted() {
+    if (!_persistDir)
+        return;
+    try {
+        const files = fs.readdirSync(_persistDir).filter((f) => f.endsWith('.json'))
+            .map((f) => { const full = path.join(_persistDir, f); return { full, t: fs.statSync(full).mtimeMs }; })
+            .sort((a, b) => b.t - a.t);
+        const now = Date.now();
+        files.forEach((f, i) => { if (i >= PERSIST_MAX_FILES || now - f.t > PERSIST_MAX_AGE_MS)
+            fs.rmSync(f.full, { force: true }); });
+    }
+    catch { /* best effort */ }
+}
 /** Store a finished sub-agent's transcript. Returns its resumable id. */
-function rememberAgent(agentName, description, messages, ownerScope = 'root') {
+function rememberAgent(agentName, description, messages, ownerScope = 'root', sessionKey) {
     // Unguessable, so an id cannot be ENUMERATED even before the ownership check runs.
     // Defence in depth only — randomness is not authorisation, `canResume` is.
     const id = `agent_${++_counter}_${(0, node_crypto_1.randomUUID)().slice(0, 8)}`;
@@ -107,7 +211,9 @@ function rememberAgent(agentName, description, messages, ownerScope = 'root') {
         updatedAt: now,
         seq: ++_seq,
         bytes: sizeOf(messages),
+        ...(sessionKey ? { sessionKey } : {}),
     });
+    persist(_agents.get(id));
     evictUntilWithinLimits();
     return id;
 }
@@ -119,18 +225,20 @@ function rememberAgent(agentName, description, messages, ownerScope = 'root') {
  * and inventing a prefix convention to fake it would be a second guessable capability.
  * The main agent is included because it owns the session and already sees every result.
  */
-function canResume(stored, scope) {
+function canResume(stored, scope, sessionKey) {
+    if (stored.sessionKey && sessionKey && stored.sessionKey !== sessionKey)
+        return false;
     return stored.ownerScope === scope || scope === 'root';
 }
 /** Append a resumed run's new messages to an existing agent. */
-function updateAgent(id, messages, scope = 'root') {
-    const existing = _agents.get(id);
+function updateAgent(id, messages, scope = 'root', sessionKey) {
+    const existing = getAgent(id);
     if (!existing)
         return;
     // Same authorisation as reading. Without it a low-privilege descendant could overwrite a
     // privileged agent's transcript while its `agentName` stayed unchanged — indirect prompt
     // injection into whatever frame resumes it next.
-    if (!canResume(existing, scope))
+    if (!canResume(existing, scope, sessionKey))
         return;
     existing.messages = messages;
     existing.updatedAt = Date.now();
@@ -140,11 +248,33 @@ function updateAgent(id, messages, scope = 'root') {
     // actively-continued agent from being evicted by a burst of new one-shots.
     _agents.delete(id);
     _agents.set(id, existing);
+    persist(existing);
     evictUntilWithinLimits();
 }
 function getAgent(id) {
-    return _agents.get(id);
+    const live = _agents.get(id);
+    if (live)
+        return live;
+    // Evicted from memory or from a previous process — fall back to disk.
+    const fromDisk = loadPersisted(id);
+    if (fromDisk) {
+        _agents.set(id, fromDisk);
+        evictUntilWithinLimits();
+    }
+    return fromDisk;
+}
+// Ids currently being resumed. Two `task` calls in one message resuming the SAME agent
+// would both start from the same transcript and the last to finish would silently
+// overwrite the other's work (updateAgent is last-write-wins).
+const _inUse = new Set();
+/** Mark an agent as being resumed. False if another run already holds it. */
+function claimAgentForResume(id) {
+    if (_inUse.has(id))
+        return false;
+    _inUse.add(id);
+    return true;
 }
+function releaseAgentForResume(id) { _inUse.delete(id); }
 /** Newest first — the order a "which agents can I resume?" list wants. */
 function listAgents() {
     return [..._agents.values()].sort((a, b) => b.seq - a.seq);

package/dist/agent/agentTypes.d.ts

@@ -56,10 +56,50 @@ export interface AgentType {
      * — a reviewer or test-writer needs the project's rules, an explorer does not.
      */
     lightPrompt?: boolean;
+    /** Tools this agent may NOT use, on top of (or instead of) an allowlist. Claude Code's `disallowedTools`. */
+    disallowedTools?: string[];
+    /** Model round-trips before the run stops and reports back (Claude Code's `maxTurns`). */
+    maxTurns?: number;
+    /** Reasoning effort for this agent's requests (low | medium | high | xhigh | max). Default: the session's. */
+    effort?: string;
+    /** Always run this agent in the background (the `task` call returns immediately). */
+    background?: boolean;
+    /** `worktree` — run in a fresh isolated worktree; removed afterwards if it made no changes. */
+    isolation?: 'worktree';
+    /** `plan` — read-only lock for this agent regardless of the session mode. Only narrowing modes are honoured. */
+    permissionMode?: 'plan';
+    /** Display colour hint for UIs. */
+    color?: string;
+    /** Skills whose instructions are preloaded into this agent's prompt (Claude Code's `skills`). */
+    skills?: string[];
+    /** MCP servers this agent may use; others' tools are neither sent nor allowed (Claude Code's `mcpServers`). */
+    mcpServers?: string[];
+    /**
+     * Hooks active only while THIS agent runs (Claude Code's agent-scoped `hooks`).
+     * Same execution model and trust gate as settings.json hooks — see trust.ts, which
+     * lists an agent file declaring hooks as a trust-sensitive file.
+     */
+    hooks?: AgentHooks;
+}
+export interface AgentHookDef {
+    type: 'command';
+    command: string;
+    timeout_ms?: number;
+}
+export interface AgentHookEntry {
+    matcher?: string;
+    hooks: AgentHookDef[];
+}
+export interface AgentHooks {
+    PreToolUse?: AgentHookEntry[];
+    PostToolUse?: AgentHookEntry[];
+    /** When this agent finishes (Claude Code: `Stop` in an agent file == SubagentStop). */
+    Stop?: AgentHookDef[];
 }
 /** Where a sub-agent's own persistent notes live. */
 export type AgentMemoryScope = 'project' | 'user' | 'local';
-export declare const VALID_MODELS: readonly ["claude-sonnet-5", "claude-opus-5-5", "claude-fable-5-1", "gpt-5.4", "gpt-5.4-mini", "gpt-4.1", "turbo", "pro", "ultra", "fast"];
+export declare function normaliseToolName(t: string): string;
+export declare const VALID_MODELS: readonly ["claude-sonnet-5-5", "claude-opus-5-5", "claude-fable-5-1", "gpt-5.4", "gpt-5.4-mini", "gpt-4.1", "turbo", "pro", "ultra", "fast"];
 /** The four tier aliases specifically (a subset of VALID_MODELS) — the only values `AgentType.model`/`Skill.model` narrow to when recognised; a real model id passes through as a plain string instead. */
 export declare const MODEL_TIER_ALIASES: readonly ["turbo", "pro", "ultra", "fast"];
 export type ModelTier = (typeof MODEL_TIER_ALIASES)[number];
@@ -94,6 +134,16 @@ export interface AgentWarning {
  * happen to contain uppercase.
  */
 export declare function parseModel(v: string | undefined): string | undefined;
+/**
+ * Read and validate an agent file's `hooks:` block. Accepts Claude Code's shape —
+ * `{ PreToolUse|PostToolUse: [{ matcher?, hooks: [{ type: command, command, timeout? }] }],
+ *    Stop|SubagentStop: [{ hooks: [...] }] }` — with `timeout` in SECONDS (Claude Code)
+ * or `timeout_ms`. Anything else is an error, never a partial guess.
+ */
+export declare function parseAgentHooks(raw: string): {
+    hooks?: AgentHooks;
+    error?: string;
+};
 /**
  * Discover all agent types. Precedence: project > global > plugin > builtin.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"agentTypes.d.ts","sourceRoot":"","sources":["../../src/agent/agentTypes.ts"],"names":[],"mappings":"AAmCA,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,MAAM,CAAC;IACf,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,MAAM,EAAE,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,cAAc,CAAC;IACrE;;;;;;;;;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;AAkX5D,eAAO,MAAM,YAAY,4IAKf,CAAC;AAEX,2MAA2M;AAC3M,eAAO,MAAM,kBAAkB,4CAA6C,CAAC;AAC7E,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5D;;;;;;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;AAOD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAMpE;AAoLD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,CAE3D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,GAAE,SAAS,EAAO,GACtB;IAAE,KAAK,EAAE,SAAS,EAAE,CAAC;IAAC,QAAQ,EAAE,YAAY,EAAE,CAAA;CAAE,CAuBlD;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;AASD,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":"AAoCA,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,MAAM,CAAC;IACf,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,MAAM,EAAE,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,cAAc,CAAC;IACrE;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,6GAA6G;IAC7G,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,0FAA0F;IAC1F,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8GAA8G;IAC9G,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qFAAqF;IACrF,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,+FAA+F;IAC/F,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,gHAAgH;IAChH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mCAAmC;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iGAAiG;IACjG,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,+GAA+G;IAC/G,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB;;;;OAIG;IACH,KAAK,CAAC,EAAE,UAAU,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAAG,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE;AACvF,MAAM,WAAW,cAAc;IAAG,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,YAAY,EAAE,CAAA;CAAE;AAC3E,MAAM,WAAW,UAAU;IACzB,UAAU,CAAC,EAAE,cAAc,EAAE,CAAC;IAC9B,WAAW,CAAC,EAAE,cAAc,EAAE,CAAC;IAC/B,uFAAuF;IACvF,IAAI,CAAC,EAAE,YAAY,EAAE,CAAC;CACvB;AAED,qDAAqD;AACrD,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,CAAC;AAgY5D,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAOnD;AAgBD,eAAO,MAAM,YAAY,8IAKf,CAAC;AAEX,2MAA2M;AAC3M,eAAO,MAAM,kBAAkB,4CAA6C,CAAC;AAC7E,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5D;;;;;;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;AAOD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CASpE;AAyOD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,KAAK,CAAC,EAAE,UAAU,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAuCnF;AAqBD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,CAE3D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,GAAE,SAAS,EAAO,GACtB;IAAE,KAAK,EAAE,SAAS,EAAE,CAAC;IAAC,QAAQ,EAAE,YAAY,EAAE,CAAA;CAAE,CAuBlD;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;AASD,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAIjG"}

package/dist/agent/agentTypes.js

@@ -34,13 +34,16 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MODEL_TIER_ALIASES = exports.VALID_MODELS = void 0;
+exports.normaliseToolName = normaliseToolName;
 exports.parseModel = parseModel;
+exports.parseAgentHooks = parseAgentHooks;
 exports.loadAgentTypes = loadAgentTypes;
 exports.loadAgentTypesWithWarnings = loadAgentTypesWithWarnings;
 exports.knownToolNames = knownToolNames;
 exports.builtinAgents = builtinAgents;
 exports.summariseAgents = summariseAgents;
 exports.findAgentType = findAgentType;
+const miniYaml_1 = require("../util/miniYaml");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
@@ -79,7 +82,7 @@ const READ_ONLY_TOOLS = [
     // 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
+    // up to 10-wide (configurable) 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.
     //
@@ -107,7 +110,9 @@ const READ_ONLY_TOOLS = [
  * without it can still search) and denies nothing. Naming the absence is the
  * only way to stop it being "helpfully" re-added.
  */
-const RESEARCH_TOOLS = [...READ_ONLY_TOOLS, 'fetch_url'];
+// web_search is a client-side tool now (executor.ts webSearch), so it must be granted
+// explicitly — planner/devops-advisor were told to use it and then refused.
+const RESEARCH_TOOLS = [...READ_ONLY_TOOLS, 'fetch_url', 'web_search'];
 /** Read-only + the write tools, for agents that produce code. */
 const WRITE_TOOLS = [
     ...READ_ONLY_TOOLS,
@@ -231,10 +236,13 @@ const BUILTIN_AGENTS = [
         lightPrompt: true,
         description: 'Fast read-only codebase explorer — 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,
-        // No `model` override — inherits the session's. A previous version forced
-        // 'turbo' (Claude Sonnet 5) on the theory that bulk search doesn't need a
-        // frontier model, but that silently billed Anthropic regardless of which
-        // provider the user actually selected for the conversation.
+        // The cheapest model of the SESSION'S OWN provider (Opus → Sonnet, GPT-6 Sol →
+        // Luna), like Claude Code's Explore on Haiku. A previous version forced 'turbo'
+        // (Claude Sonnet 5), which billed Anthropic even for DeepSeek/OpenAI sessions;
+        // 'cheapest' never leaves the provider and falls back to inheriting.
+        model: 'cheapest',
+        // Search-and-report needs breadth, not deep reasoning (Claude Code's Explore runs fast).
+        effort: 'low',
         source: 'builtin',
         prompt: [
             'You map code. You NEVER modify anything.',
@@ -383,7 +391,37 @@ const KNOWN_TOOL_NAMES = new Set([
 const KNOWN_META_KEYS = new Set([
     'name', 'description', 'tools', 'model', 'test_files_only', 'testfilesonly',
     'memory',
+    // Claude Code-compatible fields (keys arrive lowercased from parseFrontmatter).
+    'disallowedtools', 'disallowed_tools', 'maxturns', 'max_turns', 'effort', 'background',
+    'isolation', 'permissionmode', 'permission_mode', 'color',
+    'skills', 'mcpservers', 'mcp_servers', 'hooks',
 ]);
+/** Claude Code fields Nexrall recognises but does not implement — warned about by name. */
+/** Claude Code fields Nexrall recognises but does not implement — warned about by name. */
+const UNSUPPORTED_CC_KEYS = new Set([]);
+const VALID_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max'];
+/**
+ * Claude Code tool names → Nexrall's, so an agent file written for Claude Code works
+ * when dropped into .nexrall/agents/ (`tools: Read, Grep, Glob` instead of a typo warning
+ * and an agent that silently cannot read). `mcp__server__tool` → `server__tool`.
+ */
+const CLAUDE_CODE_TOOL_ALIASES = {
+    read: 'read_file', write: 'write_file', edit: 'edit_file', multiedit: 'multi_edit',
+    grep: 'search_files', glob: 'glob', ls: 'list_directory', bash: 'bash',
+    bashoutput: 'bash_output', killshell: 'kill_shell', killbash: 'kill_shell',
+    webfetch: 'fetch_url', websearch: 'web_search', todowrite: 'todo_write',
+    notebookread: 'notebook_read', notebookedit: 'notebook_edit', task: 'task', agent: 'task',
+};
+function normaliseToolName(t) {
+    if (t.startsWith('mcp__'))
+        return t.slice('mcp__'.length);
+    if (/[A-Z]/.test(t)) {
+        const alias = CLAUDE_CODE_TOOL_ALIASES[t.toLowerCase()];
+        if (alias)
+            return alias;
+    }
+    return t;
+}
 // Models this build knows how to NAME. Used only for the frontmatter warning
 // below, never to reject a value — see parseModel for why an allowlist must not
 // gate what is sent.
@@ -399,7 +437,7 @@ const KNOWN_META_KEYS = new Set([
 // at all. Two independently-maintained model lists are exactly the kind of
 // drift the shared parseFrontmatter migration was meant to end.
 exports.VALID_MODELS = [
-    'claude-sonnet-5', 'claude-opus-5-5', 'claude-fable-5-1',
+    'claude-sonnet-5-5', 'claude-opus-5-5', 'claude-fable-5-1',
     'gpt-5.4', 'gpt-5.4-mini', 'gpt-4.1',
     // Legacy tier aliases — still accepted, still resolved by the backend.
     'turbo', 'pro', 'ultra', 'fast',
@@ -433,6 +471,11 @@ function parseModel(v) {
     const lower = raw.toLowerCase();
     if (exports.MODEL_TIER_ALIASES.includes(lower))
         return lower;
+    // Resolved at dispatch against the parent's model (modelCatalogue.resolveSubAgentModel).
+    if (lower === 'inherit')
+        return undefined;
+    if (lower === 'cheapest')
+        return lower;
     return raw;
 }
 /** Parse a frontmatter boolean, accepting the usual truthy spellings. */
@@ -445,9 +488,19 @@ function parseToolList(v) {
     const tools = v
         .replace(/^\[|\]$/g, '') // tolerate [a, b] style
         .split(/[,\s]+/)
-        .map((t) => t.trim())
+        .map((t) => normaliseToolName(t.trim()))
         .filter(Boolean);
-    return tools.length ? tools : undefined;
+    return tools.length ? [...new Set(tools)] : undefined;
+}
+function parseNameList(v) {
+    if (!v)
+        return undefined;
+    const names = v.replace(/^\[|\]$/g, '').split(',').map((x) => x.trim().replace(/^['"]|['"]$/g, '')).filter(Boolean);
+    return names.length ? [...new Set(names)] : undefined;
+}
+function parsePositiveInt(v) {
+    const n = Number((v ?? '').trim());
+    return Number.isInteger(n) && n > 0 ? n : undefined;
 }
 function loadDir(dir, source, into, warnings) {
     let entries;
@@ -487,6 +540,7 @@ function loadDir(dir, source, into, warnings) {
             continue;
         const tools = parseToolList(meta.tools);
         let effectiveTools = tools;
+        let agentHooks;
         // ── FAIL CLOSED on a definition we could not parse ────────────────────────
         //
         // A file with no `---` frontmatter block used to yield tools === undefined,
@@ -568,7 +622,44 @@ function loadDir(dir, source, into, warnings) {
                     message: 'lists `task` as its ONLY tool, so it can delegate but cannot read, write or run anything itself — it has no way to do or verify work. Add the tools it needs, or drop the `tools:` line to inherit its parent\'s.',
                 });
             }
-            const strayKeys = Object.keys(meta).filter((k) => !KNOWN_META_KEYS.has(k));
+            const unsupported = Object.keys(meta).filter((k) => UNSUPPORTED_CC_KEYS.has(k));
+            if (unsupported.length) {
+                warnings.push({
+                    file: full,
+                    agent: name,
+                    message: `uses Claude Code field(s) Nexrall does not support yet: ${unsupported.join(', ')} — ignored.`,
+                });
+            }
+            const pm = (meta.permissionmode ?? meta.permission_mode)?.trim();
+            if (pm && pm !== 'plan' && pm !== 'default') {
+                warnings.push({
+                    file: full,
+                    agent: name,
+                    message: `has permissionMode: "${pm}" — only "plan" (read-only) is honoured; a definition file cannot widen the session's permissions. Ignored.`,
+                });
+            }
+            const eff = meta.effort?.trim().toLowerCase();
+            if (eff && !VALID_EFFORTS.includes(eff)) {
+                warnings.push({ file: full, agent: name, message: `has effort: "${meta.effort}" — expected one of ${VALID_EFFORTS.join(', ')}. Ignored.` });
+            }
+            const mt = meta.maxturns ?? meta.max_turns;
+            if (mt !== undefined && parsePositiveInt(mt) === undefined) {
+                warnings.push({ file: full, agent: name, message: `has maxTurns: "${mt}" — expected a positive integer. Ignored.` });
+            }
+            const iso = meta.isolation?.trim().toLowerCase();
+            if (iso && iso !== 'worktree') {
+                warnings.push({ file: full, agent: name, message: `has isolation: "${meta.isolation}" — only "worktree" is supported. Ignored.` });
+            }
+            if (meta.hooks !== undefined) {
+                const parsed = parseAgentHooks(raw);
+                if (parsed.error) {
+                    warnings.push({ file: full, agent: name, message: `has an unusable hooks: block (${parsed.error}) — no hooks will run for this agent.` });
+                }
+                else {
+                    agentHooks = parsed.hooks;
+                }
+            }
+            const strayKeys = Object.keys(meta).filter((k) => !KNOWN_META_KEYS.has(k) && !UNSUPPORTED_CC_KEYS.has(k));
             if (strayKeys.length) {
                 warnings.push({
                     file: full,
@@ -602,8 +693,100 @@ function loadDir(dir, source, into, warnings) {
             // 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) } : {}),
+            // Claude Code-compatible fields. Every one only NARROWS or tunes the agent — none
+            // can grant a tool or relax a permission, so an unreadable file (ok=false) simply
+            // has none of them.
+            ...(ok ? parseCcFields(meta) : {}),
+            ...(ok && agentHooks ? { hooks: agentHooks } : {}),
+        });
+    }
+}
+/**
+ * Read and validate an agent file's `hooks:` block. Accepts Claude Code's shape —
+ * `{ PreToolUse|PostToolUse: [{ matcher?, hooks: [{ type: command, command, timeout? }] }],
+ *    Stop|SubagentStop: [{ hooks: [...] }] }` — with `timeout` in SECONDS (Claude Code)
+ * or `timeout_ms`. Anything else is an error, never a partial guess.
+ */
+function parseAgentHooks(raw) {
+    let v;
+    try {
+        v = (0, miniYaml_1.frontmatterBlock)(raw, 'hooks');
+    }
+    catch (e) {
+        return { error: e.message };
+    }
+    if (v == null)
+        return {};
+    if (typeof v !== 'object' || Array.isArray(v))
+        return { error: 'expected a map of events' };
+    const defs = (list, where) => {
+        if (!Array.isArray(list))
+            throw new Error(`${where}: expected a list of hooks`);
+        return list.map((h, i) => {
+            const o = h;
+            if (!o || o.type !== 'command' || typeof o.command !== 'string' || !o.command.trim()) {
+                throw new Error(`${where}[${i}]: each hook needs type: command and a command`);
+            }
+            const ms = typeof o.timeout_ms === 'number' ? o.timeout_ms
+                : typeof o.timeout === 'number' ? o.timeout * 1000 : undefined;
+            return { type: 'command', command: o.command, ...(ms && ms > 0 ? { timeout_ms: ms } : {}) };
+        });
+    };
+    const entries = (list, ev) => {
+        if (!Array.isArray(list))
+            throw new Error(`${ev}: expected a list`);
+        return list.map((e, i) => {
+            const o = e;
+            if (!o || typeof o !== 'object')
+                throw new Error(`${ev}[${i}]: expected { matcher, hooks }`);
+            return {
+                ...(typeof o.matcher === 'string' && o.matcher ? { matcher: o.matcher } : {}),
+                hooks: defs(o.hooks, `${ev}[${i}].hooks`),
+            };
         });
+    };
+    try {
+        const out = {};
+        for (const [ev, val] of Object.entries(v)) {
+            if (ev === 'PreToolUse' || ev === 'PostToolUse')
+                out[ev] = entries(val, ev);
+            else if (ev === 'Stop' || ev === 'SubagentStop')
+                out.Stop = [...(out.Stop ?? []), ...entries(val, ev).flatMap((e) => e.hooks)];
+            else
+                throw new Error(`unsupported event "${ev}" (supported: PreToolUse, PostToolUse, Stop)`);
+        }
+        return { hooks: out };
     }
+    catch (e) {
+        return { error: e.message };
+    }
+}
+function parseCcFields(meta) {
+    const out = {};
+    const disallowed = parseToolList(meta.disallowedtools ?? meta.disallowed_tools);
+    if (disallowed)
+        out.disallowedTools = disallowed;
+    const mt = parsePositiveInt(meta.maxturns ?? meta.max_turns);
+    if (mt)
+        out.maxTurns = mt;
+    const eff = meta.effort?.trim().toLowerCase();
+    if (eff && VALID_EFFORTS.includes(eff))
+        out.effort = eff;
+    if (parseBool(meta.background))
+        out.background = true;
+    if (meta.isolation?.trim().toLowerCase() === 'worktree')
+        out.isolation = 'worktree';
+    if ((meta.permissionmode ?? meta.permission_mode)?.trim() === 'plan')
+        out.permissionMode = 'plan';
+    if (meta.color?.trim())
+        out.color = meta.color.trim();
+    const skills = parseNameList(meta.skills);
+    if (skills)
+        out.skills = skills;
+    const servers = parseNameList(meta.mcpservers ?? meta.mcp_servers);
+    if (servers)
+        out.mcpServers = servers;
+    return out;
 }
 /**
  * Discover all agent types. Precedence: project > global > plugin > builtin.
@@ -697,7 +880,7 @@ function summariseAgents(types) {
         const access = t.testFilesOnly
             ? 'writes TEST files only'
             : canWrite ? 'can modify files' : 'read-only';
-        const model = t.model ? `, ${t.model} model` : '';
+        const model = t.model === 'cheapest' ? ', fast low-cost model' : t.model ? `, ${t.model} model` : '';
         return `- ${t.name} (${access}${model}): ${t.description}`;
     })
         .join('\n');