botinabox 1.10.0 → 2.0.0

package/dist/index.d.ts

@@ -1831,13 +1831,15 @@ interface ToolDefinition {
     description: string;
     input_schema: Record<string, unknown>;
 }
-type ToolHandler = (input: Record<string, unknown>, context: {
+type ToolHandler = (input: Record<string, unknown>, context: ToolContext) => Promise<string>;
+interface ToolContext {
     taskId: string;
     agentId: string;
     hooks: HookBus;
+    db: DataStore;
     /** Resolve a relative file path to an absolute path (environment-aware). */
     resolveFilePath?: (path: string) => string;
-}) => Promise<string>;
+}
 interface ExecutionEngineConfig {
     /** Anthropic client instance */
     client: {
@@ -1891,6 +1893,105 @@ declare const readFileTool: {
     handler: ToolHandler;
 };
 
+/**
+ * Built-in tools: File operations — list, register, send, read.
+ */
+
+declare const listFilesTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+declare const registerFileTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+
+declare const dispatchTaskTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+declare const cancelTaskTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+declare const reassignTaskTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+
+/**
+ * Built-in tools: System awareness — task status, agent status, system health.
+ */
+
+declare const getTaskStatusTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+declare const getAgentStatusTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+declare const getSystemStatusTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+declare const getActiveTasksTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+
+/**
+ * Built-in tools: Entity lookup — agents, projects, details.
+ */
+
+declare const listAgentsTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+declare const listProjectsTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+declare const getAgentDetailTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+
+/**
+ * Built-in tools: Communication — send messages, read conversations, search history.
+ * All messaging is channel-agnostic: slack, email, discord, sms — same tools.
+ */
+
+declare const sendMessageTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+declare const addTaskCommentTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+declare const readConversationTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+declare const searchConversationTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+
+/**
+ * Built-in tools: Entity creation — agents, projects.
+ */
+
+declare const createAgentTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+declare const createProjectTool: {
+    definition: ToolDefinition;
+    handler: ToolHandler;
+};
+
 interface SecretInput {
     name: string;
     type?: string;
@@ -1979,4 +2080,4 @@ declare function isLoginRequired(stdout: string): boolean;
 /** Rewrite local image paths to prevent CLI auto-embedding as vision content. */
 declare function deactivateLocalImagePaths(prompt: string): string;
 
-export { AGENT_STATUSES, type AgentConfig, type AgentDefinition, type AgentFilter, type AgentRecord, AgentRegistry, type AgentStatus, ApiExecutionAdapter, type ApprovalResponse, type ApprovalStatus, AuditEmitter, type AuditEvent, BackupManager, type BotConfig, BreakerState, type BudgetCheck, type BudgetConfig, BudgetController, CORE_MIGRATIONS, ChannelAdapter, ChannelRegistry, ChannelRegistryError, ChatMessage, ChatResponderConfig, ChatSessionManager, CircuitBreaker, type CircuitBreakerConfig, CliExecutionAdapter, type ColumnValidator, ColumnValidatorImpl, type ConfigLoadError, type ConfigLoadResult, ConnectorConfig, DEFAULTS, DEFAULT_CONFIG, type DataConfig, DataStore, type DefaultLLMCallConfig, DeterministicAdapter, type DeterministicConfig, type DomainEntityContextOptions, type DomainSchemaOptions, DriftGate, EVENTS, type EntityColumnDef, type EntityConfig, type ExecutionAdapter, type ExecutionEngineConfig, type FeedbackEntry, type GateFinding, type GateInput, type GateResult, GateRunner, type GateVerdict, GovernanceGate, HealthStatus, HookBus, InboundMessage, LLMProvider, LearningPipeline, type LearningPipelineConfig, type LoopDetection, LoopDetector, type LoopDetectorConfig, LoopType, MAX_CHAIN_DEPTH, MessagePipeline, type ModelConfig, ModelInfo, ModelRouter, NdjsonLogger, NotificationQueue, type PackageMigration, type PackageUpdate, type ParsedStream, type PermissionPrompt, type PermissionProvider, PermissionRelay, type PermissionRelayConfig, type PlaybookEntry, ProviderRegistry, QAGate, QualityGate, RUN_STATUSES, type RenderConfig, ResolvedModel, type RetryPolicy, type RunContext, RunManager, type RunResult, type RunStatus, type SanitizerOptions, type Schedule, type ScheduleDef, Scheduler, type SchemaError, type SecretInput, type SecretMeta, SecretStore, type SecurityConfig, SessionKey, SessionManager, type SkillEntry, type StepRef, type SystemContextOptions, TASK_STATUSES, type TaskDefinition, TaskQueue, type TaskRecord, type TaskStatus, TokenUsage, type ToolDefinition, type ToolHandler, UpdateChecker, type UpdateConfig, UpdateManager, type UpdateManifest, type UsageSummary, type User, type UserInput, UserRegistry, WakeupQueue, type WorkflowConfigEntry, type WorkflowDefinition$1 as WorkflowDefinition, WorkflowEngine, type WorkflowRunRecord, type WorkflowRunStatus, type WorkflowStep$1 as WorkflowStep, type WorkflowStepConfig, type WorkflowTrigger, _resetConfig, areDependenciesMet, autoUpdate, buildAgentBindings, buildChainOrigin, buildProcessEnv, buildSystemContext, checkAllowlist, checkChainDepth, checkMentionGate, chunkText, classifyUpdate, compareVersions, createConfigRevision, createDefaultLLMCall, deactivateLocalImagePaths, defineCoreEntityContexts, defineCoreTables, defineDomainEntityContexts, defineDomainTables, detectCycle, discoverChannels, discoverProviders, formatText, getConfig, initConfig, interpolate, interpolateEnv, isLoginRequired, isMaxTurns, loadConfig, parseClaudeStream, parseVersion, readFileTool, registerExecutionEngine, runPackageMigrations, sanitize, sendFileTool, topologicalSort, truncateAtWord, validateConfig };
+export { AGENT_STATUSES, type AgentConfig, type AgentDefinition, type AgentFilter, type AgentRecord, AgentRegistry, type AgentStatus, ApiExecutionAdapter, type ApprovalResponse, type ApprovalStatus, AuditEmitter, type AuditEvent, BackupManager, type BotConfig, BreakerState, type BudgetCheck, type BudgetConfig, BudgetController, CORE_MIGRATIONS, ChannelAdapter, ChannelRegistry, ChannelRegistryError, ChatMessage, ChatResponderConfig, ChatSessionManager, CircuitBreaker, type CircuitBreakerConfig, CliExecutionAdapter, type ColumnValidator, ColumnValidatorImpl, type ConfigLoadError, type ConfigLoadResult, ConnectorConfig, DEFAULTS, DEFAULT_CONFIG, type DataConfig, DataStore, type DefaultLLMCallConfig, DeterministicAdapter, type DeterministicConfig, type DomainEntityContextOptions, type DomainSchemaOptions, DriftGate, EVENTS, type EntityColumnDef, type EntityConfig, type ExecutionAdapter, type ExecutionEngineConfig, type FeedbackEntry, type GateFinding, type GateInput, type GateResult, GateRunner, type GateVerdict, GovernanceGate, HealthStatus, HookBus, InboundMessage, LLMProvider, LearningPipeline, type LearningPipelineConfig, type LoopDetection, LoopDetector, type LoopDetectorConfig, LoopType, MAX_CHAIN_DEPTH, MessagePipeline, type ModelConfig, ModelInfo, ModelRouter, NdjsonLogger, NotificationQueue, type PackageMigration, type PackageUpdate, type ParsedStream, type PermissionPrompt, type PermissionProvider, PermissionRelay, type PermissionRelayConfig, type PlaybookEntry, ProviderRegistry, QAGate, QualityGate, RUN_STATUSES, type RenderConfig, ResolvedModel, type RetryPolicy, type RunContext, RunManager, type RunResult, type RunStatus, type SanitizerOptions, type Schedule, type ScheduleDef, Scheduler, type SchemaError, type SecretInput, type SecretMeta, SecretStore, type SecurityConfig, SessionKey, SessionManager, type SkillEntry, type StepRef, type SystemContextOptions, TASK_STATUSES, type TaskDefinition, TaskQueue, type TaskRecord, type TaskStatus, TokenUsage, type ToolContext, type ToolDefinition, type ToolHandler, UpdateChecker, type UpdateConfig, UpdateManager, type UpdateManifest, type UsageSummary, type User, type UserInput, UserRegistry, WakeupQueue, type WorkflowConfigEntry, type WorkflowDefinition$1 as WorkflowDefinition, WorkflowEngine, type WorkflowRunRecord, type WorkflowRunStatus, type WorkflowStep$1 as WorkflowStep, type WorkflowStepConfig, type WorkflowTrigger, _resetConfig, addTaskCommentTool, areDependenciesMet, autoUpdate, buildAgentBindings, buildChainOrigin, buildProcessEnv, buildSystemContext, cancelTaskTool, checkAllowlist, checkChainDepth, checkMentionGate, chunkText, classifyUpdate, compareVersions, createAgentTool, createConfigRevision, createDefaultLLMCall, createProjectTool, deactivateLocalImagePaths, defineCoreEntityContexts, defineCoreTables, defineDomainEntityContexts, defineDomainTables, detectCycle, discoverChannels, discoverProviders, dispatchTaskTool, formatText, getActiveTasksTool, getAgentDetailTool, getAgentStatusTool, getConfig, getSystemStatusTool, getTaskStatusTool, initConfig, interpolate, interpolateEnv, isLoginRequired, isMaxTurns, listAgentsTool, listFilesTool, listProjectsTool, loadConfig, parseClaudeStream, parseVersion, readConversationTool, readFileTool, reassignTaskTool, registerExecutionEngine, registerFileTool, runPackageMigrations, sanitize, searchConversationTool, sendFileTool, sendMessageTool, topologicalSort, truncateAtWord, validateConfig };

package/dist/index.js

@@ -6126,7 +6126,7 @@ ${systemContext}` : "",
             try {
               const result = await handler(
                 toolUse.input,
-                { taskId, agentId: assigneeId, hooks, resolveFilePath: config.resolveFilePath }
+                { taskId, agentId: assigneeId, hooks, db, resolveFilePath: config.resolveFilePath }
               );
               toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: result });
             } catch (err) {
@@ -6251,6 +6251,461 @@ function parseZipEntries(buf) {
   return entries;
 }
 
+// src/core/orchestrator/tools/file-ops.ts
+var listFilesTool = {
+  definition: {
+    name: "list_files",
+    description: 'List all files in the system. Shows file names, types, access levels, and paths. Use when the user asks "what files do we have?" or needs to find a document.',
+    input_schema: {
+      type: "object",
+      properties: {
+        search: { type: "string", description: "Optional search term to filter files by name" }
+      }
+    }
+  },
+  handler: async (input, ctx) => {
+    const files = await ctx.db.query("file");
+    let results = files.filter((f) => !f.deleted_at);
+    const search = input.search;
+    if (search) {
+      const lower = search.toLowerCase();
+      results = results.filter((f) => (f.name ?? "").toLowerCase().includes(lower));
+    }
+    if (results.length === 0) return "No files found.";
+    return results.map((f) => `- ${f.name} (${f.access_level ?? "internal"}) | ${f.file_path ?? "no path"}`).join("\n");
+  }
+};
+var registerFileTool = {
+  definition: {
+    name: "register_file",
+    description: "Register a new file in the vault for tracking. Use when a new document needs to be tracked by the system.",
+    input_schema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "File name/title" },
+        file_path: { type: "string", description: "Path to the file on disk" },
+        mime_type: { type: "string", description: "MIME type (e.g. application/pdf)" },
+        access_level: { type: "string", description: "Access level: internal, confidential, public" }
+      },
+      required: ["name", "file_path"]
+    }
+  },
+  handler: async (input, ctx) => {
+    const orgs = await ctx.db.query("org");
+    const orgId = orgs[0]?.id ?? "";
+    const row = await ctx.db.insert("file", {
+      org_id: orgId,
+      name: input.name,
+      file_path: input.file_path,
+      mime_type: input.mime_type ?? "application/octet-stream",
+      access_level: input.access_level ?? "internal"
+    });
+    return `File "${input.name}" registered with ID ${row.id}.`;
+  }
+};
+
+// src/core/orchestrator/tools/task-ops.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var dispatchTaskTool = {
+  definition: {
+    name: "dispatch_task",
+    description: "Create a new task and assign it to an agent. The agent will automatically pick it up and execute. Use when work needs to be delegated to a specialist.",
+    input_schema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Short task title" },
+        description: { type: "string", description: "Detailed task description" },
+        agent_slug: { type: "string", description: 'Agent slug to assign to (e.g. "engineer", "qa")' },
+        priority: { type: "number", description: "Priority 1-10 (lower = higher priority). Default: 5" }
+      },
+      required: ["title", "agent_slug"]
+    }
+  },
+  handler: async (input, ctx) => {
+    const agents = await ctx.db.query("agents", { where: { slug: input.agent_slug } });
+    const agent = agents[0];
+    if (!agent) return `Error: agent "${input.agent_slug}" not found.`;
+    const row = await ctx.db.insert("tasks", {
+      id: randomUUID2(),
+      title: input.title,
+      description: input.description ?? input.title,
+      assignee_id: agent.id,
+      priority: input.priority ?? 5,
+      status: "todo"
+    });
+    return `Task "${input.title}" dispatched to ${agent.name} (ID: ${row.id}).`;
+  }
+};
+var cancelTaskTool = {
+  definition: {
+    name: "cancel_task",
+    description: "Cancel a task by ID. Use when a task is no longer needed.",
+    input_schema: {
+      type: "object",
+      properties: {
+        task_id: { type: "string", description: "Task ID to cancel" }
+      },
+      required: ["task_id"]
+    }
+  },
+  handler: async (input, ctx) => {
+    const task = await ctx.db.get("tasks", { id: input.task_id });
+    if (!task) return `Error: task ${input.task_id} not found.`;
+    await ctx.db.update("tasks", { id: input.task_id }, { status: "cancelled" });
+    return `Task "${task.title}" cancelled.`;
+  }
+};
+var reassignTaskTool = {
+  definition: {
+    name: "reassign_task",
+    description: "Reassign a task to a different agent. Cancels the original and creates a copy for the new agent.",
+    input_schema: {
+      type: "object",
+      properties: {
+        task_id: { type: "string", description: "Task ID to reassign" },
+        new_agent_slug: { type: "string", description: "Agent slug to reassign to" }
+      },
+      required: ["task_id", "new_agent_slug"]
+    }
+  },
+  handler: async (input, ctx) => {
+    const task = await ctx.db.get("tasks", { id: input.task_id });
+    if (!task) return `Error: task ${input.task_id} not found.`;
+    const agents = await ctx.db.query("agents", { where: { slug: input.new_agent_slug } });
+    const newAgent = agents[0];
+    if (!newAgent) return `Error: agent "${input.new_agent_slug}" not found.`;
+    await ctx.db.update("tasks", { id: input.task_id }, { status: "cancelled" });
+    const row = await ctx.db.insert("tasks", {
+      id: randomUUID2(),
+      title: task.title,
+      description: task.description,
+      assignee_id: newAgent.id,
+      priority: task.priority,
+      status: "todo"
+    });
+    return `Task "${task.title}" reassigned from original to ${newAgent.name} (new ID: ${row.id}).`;
+  }
+};
+
+// src/core/orchestrator/tools/status.ts
+var getTaskStatusTool = {
+  definition: {
+    name: "get_task_status",
+    description: "Get the current status, result, and details of a specific task. Use when checking on work progress.",
+    input_schema: {
+      type: "object",
+      properties: {
+        task_id: { type: "string", description: "Task ID to check" }
+      },
+      required: ["task_id"]
+    }
+  },
+  handler: async (input, ctx) => {
+    const task = await ctx.db.get("tasks", { id: input.task_id });
+    if (!task) return `Task ${input.task_id} not found.`;
+    const agent = task.assignee_id ? await ctx.db.get("agents", { id: task.assignee_id }) : null;
+    return [
+      `**${task.title}**`,
+      `Status: ${task.status}`,
+      `Assigned to: ${agent?.name ?? "unassigned"}`,
+      `Priority: ${task.priority}`,
+      task.result ? `Result: ${task.result.slice(0, 500)}` : null
+    ].filter(Boolean).join("\n");
+  }
+};
+var getAgentStatusTool = {
+  definition: {
+    name: "get_agent_status",
+    description: "Get an agent's current status, active tasks, and recent run history. Use when checking what an agent is doing.",
+    input_schema: {
+      type: "object",
+      properties: {
+        agent_slug: { type: "string", description: 'Agent slug (e.g. "engineer")' }
+      },
+      required: ["agent_slug"]
+    }
+  },
+  handler: async (input, ctx) => {
+    const agents = await ctx.db.query("agents", { where: { slug: input.agent_slug } });
+    const agent = agents[0];
+    if (!agent) return `Agent "${input.agent_slug}" not found.`;
+    const tasks = await ctx.db.query("tasks", { where: { assignee_id: agent.id, status: "todo" } });
+    const runs = await ctx.db.query("runs", { where: { agent_id: agent.id }, limit: 5 });
+    return [
+      `**${agent.name}** (${agent.role})`,
+      `Status: ${agent.status}`,
+      `Pending tasks: ${tasks.length}`,
+      runs.length > 0 ? `Recent runs: ${runs.map((r) => `${r.status} (${r.exit_code})`).join(", ")}` : "No recent runs"
+    ].join("\n");
+  }
+};
+var getSystemStatusTool = {
+  definition: {
+    name: "get_system_status",
+    description: "Get overall system health: active agents, pending tasks, recent activity. Use for a quick system overview.",
+    input_schema: { type: "object", properties: {} }
+  },
+  handler: async (_input, ctx) => {
+    const agents = await ctx.db.query("agents");
+    const todoTasks = await ctx.db.query("tasks", { where: { status: "todo" } });
+    const runningTasks = await ctx.db.query("tasks", { where: { status: "in_progress" } });
+    const recentRuns = await ctx.db.query("runs", { limit: 5 });
+    return [
+      `Agents: ${agents.length} (${agents.filter((a) => a.status === "running").length} running)`,
+      `Pending tasks: ${todoTasks.length}`,
+      `In-progress tasks: ${runningTasks.length}`,
+      `Recent runs: ${recentRuns.length}`
+    ].join("\n");
+  }
+};
+var getActiveTasksTool = {
+  definition: {
+    name: "get_active_tasks",
+    description: "List all active (todo/in_progress) tasks across all agents. Use to see what work is pending.",
+    input_schema: { type: "object", properties: {} }
+  },
+  handler: async (_input, ctx) => {
+    const todo = await ctx.db.query("tasks", { where: { status: "todo" } });
+    const inProgress = await ctx.db.query("tasks", { where: { status: "in_progress" } });
+    const all = [...todo, ...inProgress];
+    if (all.length === 0) return "No active tasks.";
+    return all.map((t) => `- [${t.status}] ${t.title} (priority: ${t.priority})`).join("\n");
+  }
+};
+
+// src/core/orchestrator/tools/roster.ts
+var listAgentsTool = {
+  definition: {
+    name: "list_agents",
+    description: 'List all agents with their roles, status, and capabilities. Use when asking "who can do this?" or "what agents do we have?"',
+    input_schema: { type: "object", properties: {} }
+  },
+  handler: async (_input, ctx) => {
+    const agents = await ctx.db.query("agents");
+    if (agents.length === 0) return "No agents registered.";
+    return agents.filter((a) => !a.deleted_at).map((a) => `- **${a.name}** (${a.role}) \u2014 ${a.status}`).join("\n");
+  }
+};
+var listProjectsTool = {
+  definition: {
+    name: "list_projects",
+    description: "List all projects with status and description. Use when asking about company projects or work.",
+    input_schema: { type: "object", properties: {} }
+  },
+  handler: async (_input, ctx) => {
+    const projects = await ctx.db.query("project").catch(() => []);
+    if (projects.length === 0) return "No projects found.";
+    return projects.filter((p) => !p.deleted_at).map((p) => `- **${p.name}** (${p.status ?? "unknown"})${p.description ? ` \u2014 ${p.description.slice(0, 80)}` : ""}`).join("\n");
+  }
+};
+var getAgentDetailTool = {
+  definition: {
+    name: "get_agent_detail",
+    description: "Get full details about an agent: role, projects, skills, recent messages. Use when you need to know an agent's capabilities or history.",
+    input_schema: {
+      type: "object",
+      properties: {
+        agent_slug: { type: "string", description: "Agent slug" }
+      },
+      required: ["agent_slug"]
+    }
+  },
+  handler: async (input, ctx) => {
+    const agents = await ctx.db.query("agents", { where: { slug: input.agent_slug } });
+    const agent = agents[0];
+    if (!agent) return `Agent "${input.agent_slug}" not found.`;
+    const skills = await ctx.db.query("agent_skills", { where: { agent_id: agent.id } }).catch(() => []);
+    const skillNames = [];
+    for (const link of skills) {
+      const skill = await ctx.db.get("skills", { id: link.skill_id });
+      if (skill) skillNames.push(skill.name);
+    }
+    return [
+      `# ${agent.name}`,
+      `Role: ${agent.role}`,
+      `Status: ${agent.status}`,
+      `Adapter: ${agent.adapter}`,
+      skillNames.length > 0 ? `Skills: ${skillNames.join(", ")}` : "No skills assigned"
+    ].join("\n");
+  }
+};
+
+// src/core/orchestrator/tools/messaging.ts
+var sendMessageTool = {
+  definition: {
+    name: "send_message",
+    description: 'Send a message to a user or channel. Works across any channel: slack, email, discord, sms. For email, set channel="email" and include subject in the message. Use when the user asks to send/email/message someone.',
+    input_schema: {
+      type: "object",
+      properties: {
+        channel: { type: "string", description: 'Channel: "slack", "email", "discord", etc.' },
+        recipient: { type: "string", description: "Recipient: Slack user ID, email address, channel name, etc." },
+        text: { type: "string", description: "Message body" },
+        subject: { type: "string", description: "Subject line (for email channel)" }
+      },
+      required: ["channel", "recipient", "text"]
+    }
+  },
+  handler: async (input, ctx) => {
+    await ctx.hooks.emit("message.send", {
+      channel: input.channel,
+      recipient: input.recipient,
+      text: input.text,
+      subject: input.subject,
+      taskId: ctx.taskId
+    });
+    return `Message sent to ${input.recipient} via ${input.channel}.`;
+  }
+};
+var addTaskCommentTool = {
+  definition: {
+    name: "add_task_comment",
+    description: "Add a progress update or comment to a task. This syncs back to the Slack thread where the task was created. Use for mid-task status updates.",
+    input_schema: {
+      type: "object",
+      properties: {
+        task_id: { type: "string", description: "Task ID to comment on" },
+        comment: { type: "string", description: "Progress update text" }
+      },
+      required: ["task_id", "comment"]
+    }
+  },
+  handler: async (input, ctx) => {
+    const task = await ctx.db.get("tasks", { id: input.task_id });
+    if (!task) return `Task ${input.task_id} not found.`;
+    const result = (task.result ?? "") + `
+
+---
+${input.comment}`;
+    await ctx.db.update("tasks", { id: input.task_id }, { result });
+    const mappings = await ctx.db.query("thread_task_map", { where: { task_id: input.task_id } });
+    if (mappings.length > 0) {
+      await ctx.hooks.emit("response.ready", {
+        text: input.comment,
+        channel: "slack",
+        threadId: mappings[0].thread_ts,
+        taskId: input.task_id
+      });
+    }
+    return `Comment added to task "${task.title}".`;
+  }
+};
+var readConversationTool = {
+  definition: {
+    name: "read_conversation",
+    description: "Read recent messages from a channel or conversation. Use when you need context about what was discussed recently.",
+    input_schema: {
+      type: "object",
+      properties: {
+        channel: { type: "string", description: 'Channel name (e.g. "slack")' },
+        limit: { type: "number", description: "Number of recent messages to read. Default: 20" }
+      },
+      required: ["channel"]
+    }
+  },
+  handler: async (input, ctx) => {
+    const limit = input.limit ?? 20;
+    const messages = await ctx.db.query("messages", {
+      where: { channel: input.channel },
+      orderBy: "created_at",
+      limit
+    });
+    if (messages.length === 0) return `No messages found in ${input.channel}.`;
+    return messages.map((m) => {
+      const dir = m.direction === "inbound" ? "\u2192" : "\u2190";
+      const who = m.from_user ?? m.from_agent ?? "unknown";
+      return `${dir} ${who}: ${(m.body ?? "").slice(0, 200)}`;
+    }).join("\n");
+  }
+};
+var searchConversationTool = {
+  definition: {
+    name: "search_conversation",
+    description: "Search message history across all channels by keyword. Use when looking for a specific discussion, decision, or topic that was mentioned previously.",
+    input_schema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search keyword or phrase" },
+        limit: { type: "number", description: "Max results. Default: 10" }
+      },
+      required: ["query"]
+    }
+  },
+  handler: async (input, ctx) => {
+    const query = input.query;
+    const limit = input.limit ?? 10;
+    const messages = await ctx.db.query("messages", {
+      filters: [{ col: "body", op: "like", val: `%${query}%` }],
+      orderBy: "created_at",
+      limit
+    });
+    if (messages.length === 0) return `No messages found matching "${query}".`;
+    return messages.map((m) => {
+      const who = m.from_user ?? m.from_agent ?? "unknown";
+      const ts = m.created_at?.slice(0, 16) ?? "";
+      return `[${ts}] ${who}: ${(m.body ?? "").slice(0, 150)}`;
+    }).join("\n");
+  }
+};
+
+// src/core/orchestrator/tools/management.ts
+var createAgentTool = {
+  definition: {
+    name: "create_agent",
+    description: "Register a new agent in the system with a role and adapter. Use when the team needs a new specialist.",
+    input_schema: {
+      type: "object",
+      properties: {
+        slug: { type: "string", description: "Unique identifier (lowercase, no spaces)" },
+        name: { type: "string", description: "Display name" },
+        role: { type: "string", description: 'Role (e.g. "engineer", "qa", "marketing")' },
+        adapter: { type: "string", description: 'Execution adapter: "api" or "cli". Default: "api"' }
+      },
+      required: ["slug", "name", "role"]
+    }
+  },
+  handler: async (input, ctx) => {
+    const existing = await ctx.db.query("agents", { where: { slug: input.slug } });
+    if (existing.length > 0) return `Agent "${input.slug}" already exists.`;
+    const row = await ctx.db.insert("agents", {
+      slug: input.slug,
+      name: input.name,
+      role: input.role,
+      adapter: input.adapter ?? "api",
+      status: "idle",
+      adapter_config: "{}",
+      heartbeat_config: "{}"
+    });
+    return `Agent "${input.name}" (${input.role}) created with ID ${row.id}.`;
+  }
+};
+var createProjectTool = {
+  definition: {
+    name: "create_project",
+    description: "Register a new project with status and description. Use when a new initiative or product needs tracking.",
+    input_schema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Project name" },
+        status: { type: "string", description: "Status: active_build, production, planning, etc." },
+        description: { type: "string", description: "Brief description" }
+      },
+      required: ["name"]
+    }
+  },
+  handler: async (input, ctx) => {
+    const orgs = await ctx.db.query("org");
+    const orgId = orgs[0]?.id ?? "";
+    const row = await ctx.db.insert("project", {
+      org_id: orgId,
+      name: input.name,
+      status: input.status ?? "planning",
+      description: input.description ?? ""
+    });
+    return `Project "${input.name}" created with ID ${row.id}.`;
+  }
+};
+
 // src/core/orchestrator/user-registry.ts
 import { v4 as uuidv4 } from "uuid";
 var UserRegistry = class {
@@ -6632,20 +7087,24 @@ export {
   WakeupQueue,
   WorkflowEngine,
   _resetConfig,
+  addTaskCommentTool,
   areDependenciesMet,
   autoUpdate,
   buildAgentBindings,
   buildChainOrigin,
   buildProcessEnv,
   buildSystemContext,
+  cancelTaskTool,
   checkAllowlist,
   checkChainDepth,
   checkMentionGate,
   chunkText,
   classifyUpdate,
   compareVersions,
+  createAgentTool,
   createConfigRevision,
   createDefaultLLMCall,
+  createProjectTool,
   deactivateLocalImagePaths,
   defineCoreEntityContexts,
   defineCoreTables,
@@ -6654,21 +7113,35 @@ export {
   detectCycle,
   discoverChannels,
   discoverProviders,
+  dispatchTaskTool,
   formatText,
+  getActiveTasksTool,
+  getAgentDetailTool,
+  getAgentStatusTool,
   getConfig,
+  getSystemStatusTool,
+  getTaskStatusTool,
   initConfig,
   interpolate,
   interpolateEnv,
   isLoginRequired,
   isMaxTurns,
+  listAgentsTool,
+  listFilesTool,
+  listProjectsTool,
   loadConfig,
   parseClaudeStream,
   parseVersion,
+  readConversationTool,
   readFileTool,
+  reassignTaskTool,
   registerExecutionEngine,
+  registerFileTool,
   runPackageMigrations,
   sanitize,
+  searchConversationTool,
   sendFileTool,
+  sendMessageTool,
   topologicalSort,
   truncateAtWord,
   validateConfig

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botinabox",
-  "version": "1.10.0",
+  "version": "2.0.0",
   "description": "Bot in a Box — framework for building multi-agent bots",
   "type": "module",
   "main": "./dist/index.js",