neoagent 3.0.0 → 3.0.1-beta.0

package/server/routes/security.js

@@ -85,6 +85,25 @@ router.post('/approvals/:approvalId', (req, res) => {
     normalizedScope,
   );
   if (!resolved) {
+    const storedApproval = approvalGateService.getStoredApproval?.(
+      approvalId,
+      req.session.userId,
+    );
+    if (storedApproval?.status === 'expired' || storedApproval?.status === 'timeout') {
+      return res.status(410).json({
+        error: 'Approval expired because the run was interrupted or the server restarted.',
+      });
+    }
+    if (runId) {
+      const run = db.prepare(
+        'SELECT status FROM agent_runs WHERE id = ? AND user_id = ?'
+      ).get(runId, req.session.userId);
+      if (run?.status === 'interrupted') {
+        return res.status(410).json({
+          error: 'Approval expired because the run was interrupted or the server restarted.',
+        });
+      }
+    }
     return res.status(404).json({ error: 'Approval not found or already resolved' });
   }
   res.json({ ok: true, approvalId, decision, scope: normalizedScope });

package/server/routes/settings.js

@@ -40,6 +40,7 @@ const AGENT_SETTING_KEYS = new Set([
   'chat_history_window',
   'tool_replay_budget_chars',
   'subagent_max_iterations',
+  'subagent_max_children_per_run',
   'assistant_behavior_notes',
   'auto_skill_learning',
   'auto_recording_insights',

package/server/routes/skills.js

@@ -56,7 +56,7 @@ function parseSkillDocument(content) {
 router.get('/', async (req, res) => {
   try {
     const runner = await getSkillRunner(req.app);
-    const skills = runner.getAll().map(serializeInstalledSkill);
+    const skills = runner.getAll(req.session.userId).map(serializeInstalledSkill);
     res.json(skills.sort(sortInstalledSkills));
   } catch (err) {
     res.status(500).json({ error: sanitizeError(err) });
@@ -107,7 +107,7 @@ router.get('/audit/summary', (req, res) => {
 router.get('/:name', async (req, res) => {
   try {
     const runner = await getSkillRunner(req.app);
-    const skill = runner.getSkill(req.params.name);
+    const skill = runner.getSkill(req.params.name, req.session.userId);
     if (!skill) return res.status(404).json({ error: 'Skill not found' });
     const fs = require('fs');
     const content = fs.readFileSync(skill.filePath, 'utf-8');
@@ -132,6 +132,7 @@ router.post('/', async (req, res) => {
     }
 
     const result = runner.createSkill(
+      req.session.userId,
       req.body.filename || parsed.name,
       parsed.description,
       parsed.instructions,
@@ -149,7 +150,8 @@ router.put('/:name', async (req, res) => {
   try {
     const runner = await getSkillRunner(req.app);
     if (typeof req.body.enabled === 'boolean' && !req.body.content) {
-      const result = runner.setSkillEnabled(req.params.name, req.body.enabled);
+      const result = runner.setSkillEnabled(req.session.userId, req.params.name, req.body.enabled);
+      if (result.code === 'forbidden') return res.status(403).json(result);
       if (result.error) return res.status(404).json(result);
       return res.json(result);
     }
@@ -159,11 +161,12 @@ router.put('/:name', async (req, res) => {
     if (parsed.metadata?.command && !isValidCommandTemplate(parsed.metadata.command)) {
       return res.status(400).json({ error: 'Skill command template contains invalid characters' });
     }
-    const result = runner.updateSkill(req.params.name, {
+    const result = runner.updateSkill(req.session.userId, req.params.name, {
       description: parsed.description,
       instructions: parsed.instructions,
       metadata: parsed.metadata
     });
+    if (result.code === 'forbidden') return res.status(403).json(result);
     if (result.error) return res.status(404).json(result);
     res.json(result);
   } catch (err) {
@@ -174,7 +177,8 @@ router.put('/:name', async (req, res) => {
 router.delete('/:name', async (req, res) => {
   try {
     const runner = await getSkillRunner(req.app);
-    const result = runner.deleteSkill(req.params.name);
+    const result = runner.deleteSkill(req.session.userId, req.params.name);
+    if (result.code === 'forbidden') return res.status(403).json(result);
     if (result.error) return res.status(404).json(result);
     res.json(result);
   } catch (err) {

package/server/services/ai/hooks.js

@@ -81,7 +81,8 @@ class AgentHooks {
 
   /**
    * Run all handlers for an event, merging their return values.
-   * If any handler returns { block: true }, short-circuits and returns { block: true }.
+   * If any handler returns { block: true }, short-circuits and preserves the
+   * handler's metadata so the engine can explain why the tool was blocked.
    *
    * @param {string} event
    * @param {object} ctx   - Context passed to every handler
@@ -98,7 +99,7 @@ class AgentHooks {
         console.warn(`[Hooks] Handler "${id}" for "${event}" threw:`, err.message);
         continue; // don't let a bad hook crash the loop
       }
-      if (result?.block === true) return { block: true };
+      if (result?.block === true) return { ...merged, ...result };
       if (result && typeof result === 'object') {
         merged = { ...merged, ...result };
       }

package/server/services/ai/learning.js

@@ -1,5 +1,6 @@
 const crypto = require('crypto');
 const db = require('../../db/database');
+const { getAiSettings } = require('./settings');
 
 function sanitizeSkillName(input) {
   const base = String(input || '')
@@ -111,6 +112,8 @@ class LearningManager {
     if (!userId || !agentId || !runId || !task || !finalContent) return null;
     if (triggerType && triggerType !== 'user') return null;
     if (triggerSource && triggerSource !== 'web') return null;
+    const aiSettings = getAiSettings(userId, agentId);
+    if (!aiSettings.auto_skill_learning) return null;
 
     const successfulSteps = Array.isArray(steps)
       ? steps.filter((step) => step.status === 'completed' && step.tool_name)
@@ -145,12 +148,13 @@ class LearningManager {
     ).get(userId, agentId, draft.metadata.workflow_signature);
     if (Number(observation?.observation_count || 0) < 3) return null;
 
-    const existing = Array.from(this.skillRunner.skills.values()).find(
-      (skill) => skill.metadata?.workflow_signature === draft.metadata.workflow_signature,
+    const existing = this.skillRunner.findSkillByWorkflowSignature(
+      userId,
+      draft.metadata.workflow_signature,
     );
     if (existing) {
       if (existing.metadata?.enabled !== false || existing.metadata?.draft !== true) return null;
-      return this.skillRunner.updateSkill(existing.name, {
+      return this.skillRunner.updateSkill(userId, existing.name, {
         description: draft.description,
         instructions: draft.instructions,
         metadata: {
@@ -163,6 +167,7 @@ class LearningManager {
     }
 
     const result = this.skillRunner.createSkill(
+      userId,
       draft.name,
       draft.description,
       draft.instructions,

package/server/services/ai/loop/agent_engine_core.js

@@ -247,6 +247,7 @@ class AgentEngine {
     const promptSections = await buildSystemPromptSections(userId, context, memoryManager);
     const skillRunner = context.skillRunner || this.skillRunner || null;
     const skillsPrompt = skillRunner?.getSkillsForPrompt?.({
+      userId,
       maxTotalChars: 9000,
       maxDescriptionChars: 180,
       maxTriggerChars: 100,
@@ -1180,6 +1181,24 @@ class AgentEngine {
   }
 
   async spawnSubagent(userId, parentRunId, task, options = {}) {
+    const parentRunMeta = this.getRunMeta(parentRunId);
+    const parentDepth = Math.max(0, Number(parentRunMeta?.subagentDepth) || 0);
+    if (parentDepth >= 1) {
+      return {
+        error: 'Sub-agents cannot spawn additional sub-agents. Continue the current child run or return results to the parent run.',
+      };
+    }
+
+    const aiSettings = getAiSettings(userId, options.agentId || null);
+    const maxSubagentsPerRun = Math.max(1, Number(aiSettings.subagent_max_children_per_run) || 10);
+    const existingSubagents = Array.from(this.subagents.values())
+      .filter((record) => record.parentRunId === parentRunId);
+    if (existingSubagents.length >= maxSubagentsPerRun) {
+      return {
+        error: `This run has already spawned ${existingSubagents.length} sub-agents. The limit for one run is ${maxSubagentsPerRun}.`,
+      };
+    }
+
     const handle = uuidv4();
     const childRunId = uuidv4();
     let relevantMemories = [];
@@ -1256,6 +1275,8 @@ class AgentEngine {
             triggerSource: 'agent',
             runId: childRunId,
             agentId: options.agentId || null,
+            subagentDepth: parentDepth + 1,
+            disallowedToolNames: ['spawn_subagent'],
           },
           options.model || null
         );
@@ -1521,6 +1542,52 @@ class AgentEngine {
     return { handle, status: 'cancelled' };
   }
 
+  interruptRun(runId, reason = 'Server shutting down while run was in progress.') {
+    const runMeta = this.activeRuns.get(runId);
+    const delegatedChildren = db.prepare(
+      "SELECT child_run_id FROM agent_delegations WHERE parent_run_id = ? AND status = 'running'"
+    ).all(runId);
+    if (runMeta) {
+      runMeta.status = 'interrupted';
+      runMeta.stopReason = reason;
+      runMeta.aborted = true;
+      this.emit(runMeta.userId, 'run:stopping', { runId });
+      for (const pid of runMeta.toolPids) {
+        if (this.runtimeManager && typeof this.runtimeManager.killCommand === 'function') {
+          void this.runtimeManager.killCommand(runMeta.userId, pid, 'aborted');
+        }
+      }
+      runMeta.toolPids.clear();
+    }
+    for (const child of delegatedChildren) {
+      if (child.child_run_id && child.child_run_id !== runId) {
+        this.interruptRun(child.child_run_id, reason);
+      }
+    }
+    db.prepare(
+      `UPDATE agent_delegations
+       SET status = 'interrupted',
+           error = COALESCE(NULLIF(error, ''), ?),
+           updated_at = datetime('now'),
+           completed_at = datetime('now')
+       WHERE parent_run_id = ? AND status = 'running'`
+    ).run(reason, runId);
+    db.prepare(
+      `UPDATE agent_runs
+       SET status = 'interrupted',
+           error = COALESCE(NULLIF(error, ''), ?),
+           updated_at = datetime('now'),
+           completed_at = datetime('now')
+       WHERE id = ?`
+    ).run(reason, runId);
+  }
+
+  interruptAllActiveRuns(reason = 'Server shutting down while run was in progress.') {
+    for (const runId of Array.from(this.activeRuns.keys())) {
+      this.interruptRun(runId, reason);
+    }
+  }
+
   stopRun(runId) {
     const runMeta = this.activeRuns.get(runId);
     const delegatedChildren = db.prepare(

package/server/services/ai/loop/conversation_loop.js

@@ -141,6 +141,8 @@ const {
 } = require('../messagingFallback');
 const {
   classifyToolExecution,
+  isSubstantiveProgressToolName,
+  summarizeProgressToolExecutions,
   summarizeToolExecutions,
   summarizeAvailableTools,
   inferToolFailureMessage,
@@ -663,6 +665,7 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
     steeringQueue: [],
     systemSteeringQueue: [],
     toolPids: new Set(),
+    subagentDepth: Math.max(0, Number(options.subagentDepth) || 0),
     repetitionGuard: new ToolRepetitionGuard(),
     seenOutputHashes: new Map(),
     consecutiveReadOnlyIterations: 0,
@@ -715,7 +718,13 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
   const mcpManager = app?.locals?.mcpManager || app?.locals?.mcpClient || engine.mcpManager;
   const integrationManager = app?.locals?.integrationManager || null;
   const mcpTools = mcpManager ? mcpManager.getAllTools(userId, { agentId }) : [];
-  const allTools = selectToolsForTask(userMessage, builtInTools, mcpTools, options);
+  const disallowedToolNames = new Set(
+    (Array.isArray(options.disallowedToolNames) ? options.disallowedToolNames : [])
+      .map((name) => String(name || '').trim())
+      .filter(Boolean),
+  );
+  const allTools = selectToolsForTask(userMessage, builtInTools, mcpTools, options)
+    .filter((tool) => !disallowedToolNames.has(tool?.name));
   let tools = allTools;
   const toolNames = allTools.map((tool) => tool.name).filter(Boolean);
   const coreToolStatus = {
@@ -825,15 +834,21 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
           // Real, specific evidence (actual commands + their output) so the update is
           // grounded in what happened, not invented. Bare tool names make a weak model
           // confabulate generic activity ("running the build", "training").
-          const recent = summarizeToolExecutions(toolExecutions, 5) || '(no tool activity yet)';
+          const recent = summarizeProgressToolExecutions(toolExecutions, 5);
+          const currentTool = isSubstantiveProgressToolName(ledger.currentTool)
+            ? ledger.currentTool
+            : '';
+          if (!recent && !currentTool) {
+            return '';
+          }
           const priorUpdate = String(rm?.lastInterimMessage || '').trim();
           const contextBlock = [
             buildProgressUpdatePrompt(),
             stalled ? 'This step has been running a while with no new progress; reassure the user you are still on it.' : '',
             '',
             `Original request: ${summarizeForLog(userMessage, 320)}`,
-            `Doing now: ${ledger.currentTool ? `using ${ledger.currentTool}` : (ledger.currentPhase || 'thinking')}`,
-            `Actual recent tool activity (newest last) — describe ONLY this, do not extrapolate:\n${recent}`,
+            currentTool ? `Doing now: using ${currentTool}` : '',
+            recent ? `Actual recent tool activity (newest last) — describe ONLY this, do not extrapolate:\n${recent}` : '',
             priorUpdate ? `Your previous update (say something different): ${summarizeForLog(priorUpdate, 160)}` : '',
           ].filter(Boolean).join('\n');
           // Reuse the run's real system prompt so the update follows the same voice and
@@ -1922,20 +1937,41 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
     }
 
     if (engine.isRunStopped(runId)) {
-      db.prepare('UPDATE agent_runs SET status = ?, updated_at = datetime(\'now\'), completed_at = datetime(\'now\') WHERE id = ?')
-        .run('stopped', runId);
+      const stoppedRunMeta = engine.getRunMeta(runId);
+      const terminalStatus = stoppedRunMeta?.status === 'interrupted' ? 'interrupted' : 'stopped';
+      const stopReason = stoppedRunMeta?.stopReason || null;
+      db.prepare(
+        `UPDATE agent_runs
+         SET status = ?,
+             error = COALESCE(?, error),
+             updated_at = datetime('now'),
+             completed_at = datetime('now')
+         WHERE id = ?`
+      ).run(terminalStatus, stopReason, runId);
       console.warn(
-        `[Run ${shortenRunId(runId)}] stopped trigger=${triggerSource} steps=${stepIndex} tokens=${totalTokens}`
+        `[Run ${shortenRunId(runId)}] ${terminalStatus} trigger=${triggerSource} steps=${stepIndex} tokens=${totalTokens}`
       );
+      engine.cleanupSubagentsForRun(runId, { cancelRunning: true });
       engine.stopMessagingProgressSupervisor(runId);
       engine.activeRuns.delete(runId);
-      engine.emit(userId, 'run:stopped', { runId, triggerSource });
-      engine.recordRunEvent(userId, runId, 'run_stopped', {
+      engine.emit(userId, terminalStatus === 'interrupted' ? 'run:interrupted' : 'run:stopped', {
+        runId,
         triggerSource,
-        totalTokens,
-        iterations: iteration,
-      }, { agentId });
-      return { runId, content: '', totalTokens, iterations: iteration, status: 'stopped' };
+        reason: stopReason,
+      });
+      engine.recordRunEvent(
+        userId,
+        runId,
+        terminalStatus === 'interrupted' ? 'run_interrupted' : 'run_stopped',
+        {
+          triggerSource,
+          totalTokens,
+          iterations: iteration,
+          reason: stopReason,
+        },
+        { agentId },
+      );
+      return { runId, content: '', totalTokens, iterations: iteration, status: terminalStatus };
     }
 
     const runMeta = engine.activeRuns.get(runId);

package/server/services/ai/settings.js

@@ -149,6 +149,7 @@ function createDefaultAiSettings() {
     chat_history_window: 20,
     tool_replay_budget_chars: 6000,
     subagent_max_iterations: 6,
+    subagent_max_children_per_run: 10,
     assistant_behavior_notes: '',
     auto_skill_learning: false,
     auto_recording_insights: true,
@@ -330,6 +331,13 @@ function getAiSettings(userId, agentId = null) {
   settings.chat_history_window = Math.max(6, Math.min(Number(settings.chat_history_window) || DEFAULT_AI_SETTINGS.chat_history_window, 40));
   settings.tool_replay_budget_chars = Math.max(1200, Math.min(Number(settings.tool_replay_budget_chars) || DEFAULT_AI_SETTINGS.tool_replay_budget_chars, 12000));
   settings.subagent_max_iterations = Math.max(2, Math.min(Number(settings.subagent_max_iterations) || DEFAULT_AI_SETTINGS.subagent_max_iterations, 12));
+  settings.subagent_max_children_per_run = Math.max(
+    1,
+    Math.min(
+      Number(settings.subagent_max_children_per_run) || DEFAULT_AI_SETTINGS.subagent_max_children_per_run,
+      20,
+    ),
+  );
   settings.cost_mode = typeof settings.cost_mode === 'string' ? settings.cost_mode : DEFAULT_AI_SETTINGS.cost_mode;
   settings.assistant_behavior_notes = typeof settings.assistant_behavior_notes === 'string'
     ? settings.assistant_behavior_notes

package/server/services/ai/systemPrompt.js

@@ -1,8 +1,25 @@
 const os = require('os');
 
 const PROMPT_CACHE_TTL = 30_000;
+const PROMPT_CACHE_MAX = 500;
 const promptCache = new Map();
 
+function evictExpiredPromptCache() {
+  const now = Date.now();
+  for (const [key, entry] of promptCache.entries()) {
+    if (now >= entry.expiresAt) promptCache.delete(key);
+  }
+  if (promptCache.size > PROMPT_CACHE_MAX) {
+    const excess = promptCache.size - PROMPT_CACHE_MAX;
+    let deleted = 0;
+    for (const key of promptCache.keys()) {
+      if (deleted >= excess) break;
+      promptCache.delete(key);
+      deleted++;
+    }
+  }
+}
+
 function invalidateSystemPromptCache(userId, agentId = null) {
   const prefix = `${String(userId || 'global')}:${String(agentId || 'main')}:`;
   for (const key of promptCache.keys()) {
@@ -358,6 +375,7 @@ async function buildSystemPromptSections(userId, context = {}, memoryManager) {
   };
 
   if (!hasExtraContext) {
+    evictExpiredPromptCache();
     promptCache.set(cacheKey, { sections, expiresAt: now + PROMPT_CACHE_TTL });
   }
 

package/server/services/ai/toolEvidence.js

@@ -153,6 +153,27 @@ function summarizeToolExecutions(toolExecutions = [], maxItems = 10) {
   }).join('\n');
 }
 
+function isSubstantiveProgressToolName(toolName = '') {
+  const name = String(toolName || '').trim();
+  if (!name) return false;
+  if (name === 'send_message' || name === 'send_interim_update' || name === 'make_call') return false;
+  if (name === 'think' || name === 'activate_tools' || name === 'task_complete') return false;
+  return true;
+}
+
+function isSubstantiveProgressEvidence(item = {}) {
+  if (!isSubstantiveProgressToolName(item.toolName)) return false;
+  if (item.evidenceSource === 'messaging') return false;
+  return Boolean(item.evidenceRelevant || item.stateChanged || item.error);
+}
+
+function summarizeProgressToolExecutions(toolExecutions = [], maxItems = 10) {
+  return summarizeToolExecutions(
+    toolExecutions.filter(isSubstantiveProgressEvidence),
+    maxItems,
+  );
+}
+
 function summarizeAvailableTools(tools = [], { exclude = [] } = {}) {
   const excluded = new Set((Array.isArray(exclude) ? exclude : [exclude]).filter(Boolean));
   return tools
@@ -214,6 +235,9 @@ function buildAutonomousRecoveryContext({ err, toolExecutions = [], tools = [],
 module.exports = {
   classifyToolExecution,
   deriveEvidenceSource,
+  isSubstantiveProgressEvidence,
+  isSubstantiveProgressToolName,
+  summarizeProgressToolExecutions,
   summarizeToolExecutions,
   summarizeAvailableTools,
   inferToolFailureMessage,