opc-agent 1.4.0 → 2.0.1

package/src/core/runtime.ts

@@ -1,12 +1,22 @@
+import { PluginManager } from '../plugins';
+import type { Plugin } from '../plugins';
+import { loggerPlugin } from '../plugins/logger';
+import { createRateLimiterPlugin } from '../plugins/rate-limiter';
+import { createContentFilterPlugin } from '../plugins/content-filter';
 import { BaseAgent } from './agent';
 import { loadOAD } from './config';
 import { Logger } from './logger';
 import { WebChannel } from '../channels/web';
 import { TelegramChannel } from '../channels/telegram';
 import { WebSocketChannel } from '../channels/websocket';
+import { WeChatChannel } from '../channels/wechat';
+import { FeishuChannel } from '../channels/feishu';
+import { EmailChannel } from '../channels/email';
 import { DeepBrainMemoryStore } from '../memory/deepbrain';
 import { Analytics } from '../analytics';
 import type { OADDocument } from '../schema/oad';
+import { Scheduler } from './scheduler';
+import type { CronJob } from './scheduler';
 import type { ISkill, MemoryStore, Message } from './types';
 import type { Response } from 'express';
 
@@ -27,6 +37,11 @@ export class AgentRuntime {
   private shutdownHandlers: (() => Promise<void>)[] = [];
   private isShuttingDown = false;
   private analytics: Analytics = new Analytics();
+  private scheduler: Scheduler | null = null;
+  private pluginManager: PluginManager = new PluginManager();
+  private brain: any = null;
+  private agentBrain: any = null;
+  private evolveScheduler: any = null;
 
   async loadConfig(filePath: string): Promise<OADDocument> {
     this.config = loadOAD(filePath);
@@ -105,11 +120,93 @@ export class AgentRuntime {
       } else if (ch.type === 'websocket') {
         this.agent.bindChannel(new WebSocketChannel(ch.port ?? 3002));
         this.logger.info('Bound websocket channel', { port: ch.port ?? 3002 });
+      } else if (ch.type === 'wechat') {
+        this.agent.bindChannel(new WeChatChannel({
+          appId: (ch.config?.appId as string) ?? process.env.WECHAT_APP_ID ?? '',
+          appSecret: (ch.config?.appSecret as string) ?? process.env.WECHAT_APP_SECRET ?? '',
+          token: (ch.config?.token as string) ?? process.env.WECHAT_TOKEN ?? '',
+          encodingAESKey: ch.config?.encodingAESKey as string,
+          port: ch.port,
+        }));
+        this.logger.info('Bound wechat channel', { port: ch.port ?? 8080 });
+      } else if (ch.type === 'feishu') {
+        this.agent.bindChannel(new FeishuChannel({
+          appId: (ch.config?.appId as string) ?? process.env.FEISHU_APP_ID,
+          appSecret: (ch.config?.appSecret as string) ?? process.env.FEISHU_APP_SECRET,
+          verificationToken: (ch.config?.verificationToken as string) ?? process.env.FEISHU_VERIFICATION_TOKEN,
+          encryptKey: ch.config?.encryptKey as string,
+          port: ch.port,
+        }));
+        this.logger.info('Bound feishu channel', { port: ch.port ?? 8081 });
+      } else if (ch.type === 'email') {
+        this.agent.bindChannel(new EmailChannel({
+          mode: (ch.config?.mode as 'webhook' | 'imap') ?? 'webhook',
+          smtp: ch.config?.smtp as any,
+          imap: ch.config?.imap as any,
+          webhookPort: ch.port,
+          filters: ch.config?.filters as any,
+        }));
+        this.logger.info('Bound email channel', { mode: ch.config?.mode ?? 'webhook', port: ch.port ?? 8082 });
       }
     }
 
     await this.agent.init();
 
+    // === Auto-wire DeepBrain long-term memory (Brain/AgentBrain) ===
+    const longTermCfg = memCfg && typeof memCfg.longTerm === 'object' ? memCfg.longTerm : null;
+    if (longTermCfg?.provider === 'deepbrain') {
+      try {
+        const deepbrainModule = await import(/* webpackIgnore: true */ 'deepbrain');
+        const BrainClass = deepbrainModule.Brain ?? deepbrainModule.default?.Brain;
+        const AgentBrainClass = deepbrainModule.AgentBrain ?? deepbrainModule.default?.AgentBrain;
+
+        if (BrainClass && AgentBrainClass) {
+          const dbConfig = longTermCfg.config ?? {};
+          const dbPath = (dbConfig as any).database || './data/brain.db';
+          const embeddingProvider = (dbConfig as any).embeddingProvider || 'ollama';
+
+          this.brain = new BrainClass({
+            database: dbPath,
+            embedding_provider: embeddingProvider,
+          });
+          await this.brain.connect();
+
+          this.agentBrain = new AgentBrainClass(this.brain, cfg.metadata.name);
+          this.agent.setLongTermMemory(this.agentBrain, {
+            autoLearn: (dbConfig as any).autoLearn !== false,
+            autoRecall: (dbConfig as any).autoRecall !== false,
+          });
+
+          this.logger.info('DeepBrain Brain/AgentBrain connected', { database: dbPath });
+
+          // Brain seed loading
+          const { existsSync, readFileSync, renameSync } = await import('fs');
+          const seedPath = './data/brain-seed.md';
+          if (existsSync(seedPath)) {
+            const seed = readFileSync(seedPath, 'utf-8');
+            await this.brain.put('brain-seed', seed, { type: 'seed', tags: ['seed', 'initial'] });
+            renameSync(seedPath, './data/brain-seed.loaded.md');
+            this.logger.info('Brain seed loaded');
+          }
+
+          // Auto-evolve scheduling
+          const evolveInterval = (dbConfig as any).evolveInterval;
+          if (evolveInterval && evolveInterval > 0) {
+            const AutoEvolveSchedulerClass = deepbrainModule.AutoEvolveScheduler ?? deepbrainModule.default?.AutoEvolveScheduler;
+            if (AutoEvolveSchedulerClass) {
+              this.evolveScheduler = new AutoEvolveSchedulerClass();
+              this.evolveScheduler.start(this.agentBrain, evolveInterval);
+              this.logger.info('DeepBrain auto-evolve scheduled', { interval: evolveInterval });
+            }
+          }
+        } else {
+          this.logger.warn('DeepBrain module found but Brain/AgentBrain classes not available');
+        }
+      } catch (e: any) {
+        this.logger.warn('DeepBrain not available (install with: npm install deepbrain)', { error: e.message });
+      }
+    }
+
     // Wire analytics to agent events
     this.agent.on('message:out', () => {
       // responseTime is approximated; real timing is done via skill/llm events
@@ -122,6 +219,60 @@ export class AgentRuntime {
     });
 
     this.logger.info('Agent initialized', { name: cfg.metadata.name });
+
+    // Load enhanced plugins from OAD config
+    const pluginsCfg = (cfg.spec as any).plugins;
+    if (pluginsCfg && Array.isArray(pluginsCfg)) {
+      const builtinPlugins: Record<string, (config?: any) => Plugin> = {
+        'logger': () => loggerPlugin,
+        'rate-limiter': (c: any) => createRateLimiterPlugin(c?.maxPerMinute ?? 60),
+        'content-filter': (c: any) => createContentFilterPlugin(c?.blocklist ?? []),
+      };
+      for (const entry of pluginsCfg) {
+        const factory = builtinPlugins[entry.name];
+        if (factory) {
+          this.pluginManager.registerEnhanced(factory(entry.config));
+          this.logger.info('Enhanced plugin loaded from config', { name: entry.name });
+        }
+      }
+    }
+    await this.pluginManager.initAll(this);
+
+    // Initialize scheduler if jobs are configured
+    const schedulerCfg = (cfg.spec as any).scheduler;
+    if (schedulerCfg?.jobs && Array.isArray(schedulerCfg.jobs) && schedulerCfg.jobs.length > 0) {
+      this.scheduler = new Scheduler(async (job: CronJob) => {
+        this.logger.info('Scheduler firing job', { name: job.name, task: job.task });
+        if (this.agent) {
+          const msg: Message = {
+            id: `cron-${job.id}-${Date.now()}`,
+            role: 'user',
+            content: job.task,
+            timestamp: Date.now(),
+            metadata: { source: 'scheduler', jobId: job.id, jobName: job.name },
+          };
+          try {
+            await this.agent.handleMessage(msg);
+          } catch (err) {
+            this.logger.error('Scheduler job failed', { name: job.name, error: err instanceof Error ? err.message : String(err) });
+          }
+        }
+      });
+
+      for (let i = 0; i < schedulerCfg.jobs.length; i++) {
+        const j = schedulerCfg.jobs[i];
+        const id = j.id || j.name?.toLowerCase().replace(/\s+/g, '-') || `job-${i}`;
+        this.scheduler.addJob({
+          id,
+          name: j.name || id,
+          schedule: j.schedule,
+          task: j.task || '',
+          enabled: j.enabled !== false,
+        });
+      }
+      this.logger.info('Scheduler configured', { jobs: schedulerCfg.jobs.length });
+    }
+
     return this.agent;
   }
 
@@ -129,12 +280,31 @@ export class AgentRuntime {
     if (!this.agent) throw new Error('Agent not initialized.');
     this.setupGracefulShutdown();
     await this.agent.start();
+    if (this.scheduler) {
+      this.scheduler.start();
+      this.logger.info('Scheduler started');
+    }
     this.logger.info('Agent started');
   }
 
   async stop(): Promise<void> {
     if (!this.agent) return;
     this.logger.info('Stopping agent...');
+    if (this.evolveScheduler) {
+      try { this.evolveScheduler.stop(); } catch { /* ignore */ }
+      this.logger.info('DeepBrain auto-evolve stopped');
+    }
+    if (this.brain) {
+      try {
+        await this.brain.disconnect();
+        this.logger.info('DeepBrain disconnected');
+      } catch { /* ignore */ }
+    }
+    if (this.scheduler) {
+      this.scheduler.stop();
+      this.logger.info('Scheduler stopped');
+    }
+    await this.pluginManager.shutdownAll();
     await this.agent.stop();
     for (const handler of this.shutdownHandlers) {
       await handler();
@@ -180,4 +350,8 @@ export class AgentRuntime {
   getConfig(): OADDocument | null {
     return this.config;
   }
+
+  getPluginManager(): PluginManager {
+    return this.pluginManager;
+  }
 }

package/src/core/sandbox.ts

@@ -1,11 +1,30 @@
 import type { TrustLevelType } from '../schema/oad';
 import * as path from 'path';
+import * as fs from 'fs';
 
 export interface SandboxConfig {
   trustLevel: TrustLevelType;
   agentDir: string;
   networkAllowlist?: string[];
   shellAllowed?: boolean;
+  allowedCommands?: string[];
+  blockedCommands?: string[];
+  maxFileSize?: number;       // bytes, default 10MB
+  maxFiles?: number;          // max files in workspace, default 1000
+  networkAccess?: boolean;    // allow network, default true
+  readOnlyPaths?: string[];   // paths that can't be written
+  timeout?: number;           // global timeout ms
+}
+
+export interface ValidationResult {
+  allowed: boolean;
+  reason?: string;
+}
+
+export interface SandboxStatus {
+  files: number;
+  totalSize: number;
+  violations: number;
 }
 
 export interface SandboxRestrictions {
@@ -40,6 +59,9 @@ const TRUST_RESTRICTIONS: Record<string, SandboxRestrictions> = {
 export class Sandbox {
   private config: SandboxConfig;
   private restrictions: SandboxRestrictions;
+  private violations: number = 0;
+  private maxFileSize: number;
+  private maxFiles: number;
 
   constructor(config: SandboxConfig) {
     this.config = config;
@@ -52,6 +74,11 @@ export class Sandbox {
     if (config.shellAllowed !== undefined) {
       this.restrictions.shell = config.shellAllowed;
     }
+    if (config.networkAccess === false) {
+      this.restrictions.network.allowed = [];
+    }
+    this.maxFileSize = config.maxFileSize ?? 10 * 1024 * 1024; // 10MB
+    this.maxFiles = config.maxFiles ?? 1000;
   }
 
   get trustLevel(): TrustLevelType {
@@ -98,4 +125,120 @@ export class Sandbox {
   checkShellAccess(): boolean {
     return this.restrictions.shell;
   }
+
+  validateFileOp(action: 'read' | 'write' | 'delete', filePath: string): ValidationResult {
+    const resolved = path.resolve(filePath);
+
+    if (action === 'write' || action === 'delete') {
+      // Check read-only paths
+      if (this.config.readOnlyPaths) {
+        for (const ro of this.config.readOnlyPaths) {
+          const roResolved = path.resolve(ro);
+          if (resolved.startsWith(roResolved) || resolved === roResolved) {
+            this.violations++;
+            return { allowed: false, reason: `Path is read-only: ${ro}` };
+          }
+        }
+      }
+
+      // Check file size for writes
+      if (action === 'write') {
+        try {
+          if (fs.existsSync(resolved)) {
+            const stat = fs.statSync(resolved);
+            if (stat.size > this.maxFileSize) {
+              this.violations++;
+              return { allowed: false, reason: `File exceeds max size: ${this.maxFileSize} bytes` };
+            }
+          }
+        } catch {
+          // File doesn't exist yet — that's fine
+        }
+      }
+    }
+
+    const mode = action === 'read' ? 'read' : 'write';
+    if (!this.checkFileAccess(filePath, mode)) {
+      this.violations++;
+      return { allowed: false, reason: `File access denied for ${action}: ${filePath}` };
+    }
+
+    return { allowed: true };
+  }
+
+  validateCommand(command: string): ValidationResult {
+    if (!this.restrictions.shell) {
+      this.violations++;
+      return { allowed: false, reason: 'Shell access is disabled' };
+    }
+
+    // Check blocklist
+    if (this.config.blockedCommands) {
+      for (const blocked of this.config.blockedCommands) {
+        if (command.includes(blocked)) {
+          this.violations++;
+          return { allowed: false, reason: `Command is blocked: ${blocked}` };
+        }
+      }
+    }
+
+    // Check allowlist (if set, only allowed commands pass)
+    if (this.config.allowedCommands && this.config.allowedCommands.length > 0) {
+      const allowed = this.config.allowedCommands.some(a => command.startsWith(a) || command.includes(a));
+      if (!allowed) {
+        this.violations++;
+        return { allowed: false, reason: 'Command not in allowlist' };
+      }
+    }
+
+    return { allowed: true };
+  }
+
+  validateNetwork(url: string): ValidationResult {
+    if (this.config.networkAccess === false) {
+      this.violations++;
+      return { allowed: false, reason: 'Network access is disabled' };
+    }
+    if (!this.checkNetworkAccess(url)) {
+      this.violations++;
+      return { allowed: false, reason: `Network access denied for: ${url}` };
+    }
+    return { allowed: true };
+  }
+
+  getStatus(): SandboxStatus {
+    let files = 0;
+    let totalSize = 0;
+    try {
+      const agentDir = path.resolve(this.config.agentDir);
+      if (fs.existsSync(agentDir)) {
+        const countFiles = (dir: string) => {
+          const entries = fs.readdirSync(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory() && entry.name !== 'node_modules') {
+              countFiles(full);
+            } else if (entry.isFile()) {
+              files++;
+              try { totalSize += fs.statSync(full).size; } catch {}
+            }
+          }
+        };
+        countFiles(agentDir);
+      }
+    } catch {}
+    return { files, totalSize, violations: this.violations };
+  }
+
+  getViolations(): number {
+    return this.violations;
+  }
+
+  getMaxFileSize(): number {
+    return this.maxFileSize;
+  }
+
+  getMaxFiles(): number {
+    return this.maxFiles;
+  }
 }

package/src/core/scheduler.ts

@@ -0,0 +1,187 @@
+/**
+ * Simple cron scheduler — no external dependencies.
+ * Supports cron expressions: star, star-slash-N, M-N, M,N for minute/hour/day/month/weekday.
+ */
+
+export interface CronJob {
+  id: string;
+  name: string;
+  schedule: string;
+  task: string;
+  enabled: boolean;
+  lastRun?: Date;
+  nextRun?: Date;
+}
+
+type CronField = { type: 'any' } | { type: 'every'; step: number } | { type: 'list'; values: number[] };
+
+interface ParsedCron {
+  minute: CronField;
+  hour: CronField;
+  dayOfMonth: CronField;
+  month: CronField;
+  dayOfWeek: CronField;
+}
+
+function parseField(field: string, min: number, max: number): CronField {
+  if (field === '*') return { type: 'any' };
+  if (field.startsWith('*/')) {
+    const step = parseInt(field.slice(2), 10);
+    if (isNaN(step) || step <= 0) throw new Error(`Invalid cron step: ${field}`);
+    return { type: 'every', step };
+  }
+  // Could be comma-separated, each part could be a range
+  const values: number[] = [];
+  for (const part of field.split(',')) {
+    if (part.includes('-')) {
+      const [a, b] = part.split('-').map(Number);
+      if (isNaN(a) || isNaN(b)) throw new Error(`Invalid cron range: ${part}`);
+      for (let i = a; i <= b; i++) values.push(i);
+    } else {
+      const n = parseInt(part, 10);
+      if (isNaN(n)) throw new Error(`Invalid cron value: ${part}`);
+      values.push(n);
+    }
+  }
+  return { type: 'list', values };
+}
+
+export function parseCron(expr: string): ParsedCron {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) throw new Error(`Invalid cron expression (need 5 fields): ${expr}`);
+  return {
+    minute: parseField(parts[0], 0, 59),
+    hour: parseField(parts[1], 0, 23),
+    dayOfMonth: parseField(parts[2], 1, 31),
+    month: parseField(parts[3], 1, 12),
+    dayOfWeek: parseField(parts[4], 0, 6),
+  };
+}
+
+function fieldMatches(field: CronField, value: number): boolean {
+  switch (field.type) {
+    case 'any': return true;
+    case 'every': return value % field.step === 0;
+    case 'list': return field.values.includes(value);
+  }
+}
+
+export function cronMatches(parsed: ParsedCron, date: Date): boolean {
+  return (
+    fieldMatches(parsed.minute, date.getMinutes()) &&
+    fieldMatches(parsed.hour, date.getHours()) &&
+    fieldMatches(parsed.dayOfMonth, date.getDate()) &&
+    fieldMatches(parsed.month, date.getMonth() + 1) &&
+    fieldMatches(parsed.dayOfWeek, date.getDay())
+  );
+}
+
+/** Compute approximate next run (scans forward up to 48h). */
+function computeNextRun(parsed: ParsedCron, from: Date): Date | undefined {
+  const d = new Date(from);
+  d.setSeconds(0, 0);
+  d.setMinutes(d.getMinutes() + 1);
+  const limit = 48 * 60; // 48 hours in minutes
+  for (let i = 0; i < limit; i++) {
+    if (cronMatches(parsed, d)) return new Date(d);
+    d.setMinutes(d.getMinutes() + 1);
+  }
+  return undefined;
+}
+
+export type JobHandler = (job: CronJob) => void | Promise<void>;
+
+export class Scheduler {
+  private jobs = new Map<string, CronJob>();
+  private parsed = new Map<string, ParsedCron>();
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private handler: JobHandler;
+
+  constructor(handler: JobHandler) {
+    this.handler = handler;
+  }
+
+  addJob(job: CronJob): void {
+    const p = parseCron(job.schedule);
+    this.parsed.set(job.id, p);
+    job.nextRun = computeNextRun(p, new Date()) ?? undefined;
+    this.jobs.set(job.id, job);
+  }
+
+  removeJob(id: string): void {
+    this.jobs.delete(id);
+    this.parsed.delete(id);
+  }
+
+  enableJob(id: string): void {
+    const job = this.jobs.get(id);
+    if (job) job.enabled = true;
+  }
+
+  disableJob(id: string): void {
+    const job = this.jobs.get(id);
+    if (job) job.enabled = false;
+  }
+
+  getJobs(): CronJob[] {
+    return Array.from(this.jobs.values());
+  }
+
+  getJob(id: string): CronJob | undefined {
+    return this.jobs.get(id);
+  }
+
+  /** Run a specific job immediately */
+  async runJob(id: string): Promise<boolean> {
+    const job = this.jobs.get(id);
+    if (!job) return false;
+    job.lastRun = new Date();
+    await this.handler(job);
+    const parsed = this.parsed.get(id);
+    if (parsed) job.nextRun = computeNextRun(parsed, new Date());
+    return true;
+  }
+
+  start(): void {
+    if (this.timer) return;
+    // Check every 60 seconds
+    this.timer = setInterval(() => this.tick(), 60_000);
+    // Also tick immediately
+    this.tick();
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  private tick(): void {
+    const now = new Date();
+    for (const [id, job] of this.jobs) {
+      if (!job.enabled) continue;
+      const parsed = this.parsed.get(id);
+      if (!parsed) continue;
+      if (cronMatches(parsed, now)) {
+        // Avoid double-fire: check lastRun isn't same minute
+        if (job.lastRun) {
+          const last = job.lastRun;
+          if (last.getFullYear() === now.getFullYear() &&
+              last.getMonth() === now.getMonth() &&
+              last.getDate() === now.getDate() &&
+              last.getHours() === now.getHours() &&
+              last.getMinutes() === now.getMinutes()) {
+            continue;
+          }
+        }
+        job.lastRun = new Date(now);
+        job.nextRun = computeNextRun(parsed, now);
+        // Fire and forget (log errors)
+        Promise.resolve(this.handler(job)).catch((err) => {
+          console.error(`[scheduler] Job "${job.name}" failed:`, err);
+        });
+      }
+    }
+  }
+}

package/src/core/subagent.ts

@@ -0,0 +1,98 @@
+import { BaseAgent } from './agent';
+import { InMemoryStore } from '../memory';
+import type { Message } from './types';
+
+export interface SubAgentConfig {
+  name: string;
+  task: string;
+  systemPrompt?: string;
+  provider?: string;
+  model?: string;
+  timeout?: number;
+  isolated?: boolean;
+}
+
+export interface SubAgentResult {
+  id: string;
+  name: string;
+  status: 'completed' | 'failed' | 'timeout';
+  result: string;
+  duration: number;
+}
+
+interface SubAgentEntry {
+  agent: BaseAgent;
+  status: string;
+  name: string;
+}
+
+export class SubAgentManager {
+  private agents: Map<string, SubAgentEntry> = new Map();
+
+  async spawn(config: SubAgentConfig, parentProvider?: any): Promise<SubAgentResult> {
+    const id = `sub_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const timeout = config.timeout ?? 300000;
+    const isolated = config.isolated !== false;
+
+    const agent = new BaseAgent({
+      name: config.name,
+      systemPrompt: config.systemPrompt ?? 'You are a helpful sub-agent.',
+      provider: config.provider ?? 'openai',
+      model: config.model,
+      memory: isolated ? new InMemoryStore() : undefined,
+    });
+
+    this.agents.set(id, { agent, status: 'running', name: config.name });
+
+    const message: Message = {
+      id: `msg_${Date.now()}`,
+      role: 'user',
+      content: config.task,
+      timestamp: Date.now(),
+      metadata: { subAgentId: id },
+    };
+
+    const start = Date.now();
+
+    try {
+      const result = await Promise.race([
+        agent.handleMessage(message),
+        new Promise<never>((_, reject) =>
+          setTimeout(() => reject(new Error('SubAgent timeout')), timeout),
+        ),
+      ]);
+
+      const duration = Date.now() - start;
+      this.agents.set(id, { agent, status: 'completed', name: config.name });
+
+      return { id, name: config.name, status: 'completed', result: result.content, duration };
+    } catch (err) {
+      const duration = Date.now() - start;
+      const isTimeout = (err as Error).message.includes('timeout');
+      const status = isTimeout ? 'timeout' : 'failed';
+      this.agents.set(id, { agent, status, name: config.name });
+
+      return { id, name: config.name, status, result: (err as Error).message, duration };
+    }
+  }
+
+  async spawnParallel(configs: SubAgentConfig[], parentProvider?: any): Promise<SubAgentResult[]> {
+    return Promise.all(configs.map((c) => this.spawn(c, parentProvider)));
+  }
+
+  list(): Array<{ id: string; name: string; status: string }> {
+    return Array.from(this.agents.entries()).map(([id, entry]) => ({
+      id,
+      name: entry.name,
+      status: entry.status,
+    }));
+  }
+
+  kill(id: string): boolean {
+    const entry = this.agents.get(id);
+    if (!entry) return false;
+    entry.status = 'killed';
+    this.agents.set(id, entry);
+    return true;
+  }
+}