@bike4mind/cli 0.2.58 → 0.2.59-feat-cli-tavern-integration.21571

package/dist/index.js

@@ -22,6 +22,7 @@ import {
   WebSocketToolExecutor,
   buildCoreSystemPrompt,
   buildSkillsPromptSection,
+  clearFeatureModuleTools,
   createAgentDelegateTool,
   createBackgroundAgentTools,
   createFindDefinitionTool,
@@ -41,12 +42,13 @@ import {
   mergeCommands,
   parseAgentConfig,
   processFileReferences,
+  registerFeatureModuleTools,
   searchCommands,
   searchFiles,
   setWebSocketToolExecutor,
   substituteArguments,
   warmFileCache
-} from "./chunk-WPK7K4BM.js";
+} from "./chunk-BPUFVNEJ.js";
 import "./chunk-BDQBOLYG.js";
 import "./chunk-5TQE3IBF.js";
 import "./chunk-GQGOWACU.js";
@@ -60,15 +62,15 @@ import "./chunk-BPFEGDC7.js";
 import {
   ConfigStore,
   logger
-} from "./chunk-RB5GFKSM.js";
+} from "./chunk-U52SND4Y.js";
 import {
   checkForUpdate,
   package_default
-} from "./chunk-XZLLBLTF.js";
+} from "./chunk-PEG5MIUM.js";
 import {
   selectActiveBackgroundAgents,
   useCliStore
-} from "./chunk-G2LYCVZJ.js";
+} from "./chunk-Y4WOJJM3.js";
 import {
   CREDIT_DEDUCT_TRANSACTION_TYPES,
   ChatModels,
@@ -1422,6 +1424,19 @@ function buildConfigItems(availableModels) {
           enableDynamicAgentCreation: value
         }
       })
+    },
+    {
+      key: "featuresTavern",
+      label: "Tavern",
+      type: "boolean",
+      getValue: (config) => config.features?.tavern ?? false,
+      setValue: (config, value) => ({
+        ...config,
+        features: {
+          ...config.features,
+          tavern: value
+        }
+      })
     }
   );
   return items;
@@ -1433,8 +1448,15 @@ function ConfigEditor({ config, availableModels, onSave, onClose }) {
   const [isSaving, setIsSaving] = useState7(false);
   const configItems = useMemo3(() => buildConfigItems(availableModels), [availableModels]);
   const hasChanges = useMemo3(() => {
-    return JSON.stringify(config.preferences) !== JSON.stringify(editedConfig.preferences) || config.defaultModel !== editedConfig.defaultModel;
-  }, [config.preferences, editedConfig.preferences, config.defaultModel, editedConfig.defaultModel]);
+    return JSON.stringify(config.preferences) !== JSON.stringify(editedConfig.preferences) || config.defaultModel !== editedConfig.defaultModel || JSON.stringify(config.features) !== JSON.stringify(editedConfig.features);
+  }, [
+    config.preferences,
+    editedConfig.preferences,
+    config.defaultModel,
+    editedConfig.defaultModel,
+    config.features,
+    editedConfig.features
+  ]);
   const handleSaveAndClose = async () => {
     if (hasChanges) {
       try {
@@ -2982,6 +3004,942 @@ Unlike agent_delegate (which uses pre-defined agents), this tool lets you compos
   };
 }
 
+// src/features/FeatureModuleRegistry.ts
+var FeatureModuleRegistry = class {
+  constructor() {
+    this.modules = [];
+  }
+  /** Register a feature module */
+  register(module) {
+    if (this.modules.some((m) => m.name === module.name)) {
+      throw new Error(`Feature module '${module.name}' is already registered`);
+    }
+    this.modules.push(module);
+  }
+  /** Collect all tools from all registered modules */
+  getAllTools() {
+    return this.modules.flatMap((m) => m.getTools());
+  }
+  /** Get all tool names from all registered modules */
+  getAllToolNames() {
+    return this.getAllTools().map((t) => t.toolSchema.name);
+  }
+  /** Build combined system prompt section from all modules */
+  getSystemPromptSections() {
+    const sections = this.modules.map((m) => m.getSystemPromptSection()).filter((s) => s.length > 0);
+    return sections.length > 0 ? "\n\n" + sections.join("\n\n") : "";
+  }
+  /** Register all WS handlers from all modules */
+  registerAllWsHandlers(wsManager) {
+    for (const module of this.modules) {
+      module.registerWsHandlers?.(wsManager);
+    }
+  }
+  /** Collect all slash commands from all registered modules */
+  getAllCommands() {
+    return this.modules.flatMap((m) => m.getCommands?.() ?? []);
+  }
+  /** Try to execute a slash command. Returns true if handled. */
+  executeCommand(name, args) {
+    for (const module of this.modules) {
+      const commands = module.getCommands?.() ?? [];
+      const command = commands.find((c) => c.name === name);
+      if (command) {
+        command.execute(args);
+        return true;
+      }
+    }
+    return false;
+  }
+  /** Cleanup all modules */
+  disposeAll() {
+    for (const module of this.modules) {
+      module.dispose?.();
+    }
+  }
+  /** Get names of all registered modules */
+  getModuleNames() {
+    return this.modules.map((m) => m.name);
+  }
+  /** Check if any modules are registered */
+  get hasModules() {
+    return this.modules.length > 0;
+  }
+};
+
+// src/features/tavern/TavernService.ts
+var TavernService = class {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+  }
+  async listAgents() {
+    return this.apiClient.get("/api/agents?limit=100");
+  }
+  async createAgent(request) {
+    return this.apiClient.post("/api/agents", request);
+  }
+  async updateAgent(agentId, request) {
+    return this.apiClient.put(`/api/agents/${encodeURIComponent(agentId)}`, request);
+  }
+  async deleteAgent(agentId) {
+    await this.apiClient.delete(`/api/agents/${encodeURIComponent(agentId)}`);
+  }
+  async mentionAgent(agentName, message, config) {
+    return this.apiClient.post("/api/tavern/mention", {
+      agentName,
+      message,
+      config
+    });
+  }
+  async listQuests() {
+    return this.apiClient.get("/api/tavern/quests");
+  }
+  async postQuest(request) {
+    return this.apiClient.post("/api/tavern/quests", request);
+  }
+  async deleteQuest(questId) {
+    await this.apiClient.delete(`/api/tavern/quests`, { data: { questId } });
+  }
+  async getAgentNotebook(agentId, limit = 50) {
+    return this.apiClient.get(
+      `/api/tavern/agent-notebook?agentId=${encodeURIComponent(agentId)}&limit=${limit}`
+    );
+  }
+  async listGates() {
+    return this.apiClient.get("/api/tavern/gates");
+  }
+  async resolveGate(gateId, resolution) {
+    return this.apiClient.post("/api/tavern/gate-resolve", {
+      gateId,
+      resolution
+    });
+  }
+  async toggleHeartbeats(enabled) {
+    return this.apiClient.post("/api/tavern/toggle-heartbeats", { enabled });
+  }
+  async triggerHeartbeat(config) {
+    return this.apiClient.post("/api/tavern/trigger-heartbeat", { config });
+  }
+  async abortHeartbeats() {
+    await this.apiClient.post("/api/tavern/abort-heartbeats", { abort: true });
+  }
+};
+
+// src/features/tavern/types.ts
+import { z } from "zod";
+var HeartbeatLogEntrySchema = z.object({
+  id: z.string(),
+  agentId: z.string(),
+  agentName: z.string(),
+  action: z.enum([
+    "idle",
+    "speech",
+    "thought",
+    "memory",
+    "move",
+    "reply",
+    "post_quest",
+    "claim_quest",
+    "complete_quest",
+    "tool_use",
+    "email",
+    "move_decoration",
+    "gate_paused",
+    "gate_timed",
+    "gate_proceed",
+    "yolo_override",
+    "intent",
+    "report",
+    "credits"
+  ]),
+  text: z.string().optional(),
+  toolOutput: z.string().optional(),
+  targetAgentName: z.string().optional(),
+  threadId: z.string().optional(),
+  timestamp: z.string(),
+  burstId: z.string().optional(),
+  stepIndex: z.number().optional(),
+  totalSteps: z.number().optional(),
+  confidence: z.number().optional(),
+  confidenceSource: z.string().optional(),
+  creditsUsed: z.number().optional()
+});
+var CreateAgentRequestSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  systemPrompt: z.string().optional(),
+  personality: z.object({
+    majorMotivation: z.string().optional(),
+    minorMotivation: z.string().optional(),
+    flaw: z.string().optional(),
+    quirk: z.string().optional(),
+    description: z.string().optional(),
+    personalMission: z.string().optional(),
+    activeProject: z.string().optional(),
+    communicationPattern: z.string().optional(),
+    humorStyle: z.string().optional(),
+    backstoryElement: z.string().optional(),
+    energyLevel: z.string().optional(),
+    coreValues: z.string().optional()
+  }).optional()
+});
+var CreateAgentResponseSchema = z.object({
+  _id: z.string(),
+  name: z.string(),
+  description: z.string().optional()
+});
+var UpdateAgentRequestSchema = CreateAgentRequestSchema.partial().extend({
+  heartbeatConfig: z.object({
+    enabled: z.boolean().optional(),
+    intervalMinutes: z.number().optional()
+  }).optional()
+});
+var AgentSummarySchema = z.object({
+  _id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  heartbeatConfig: z.object({
+    enabled: z.boolean().optional()
+  }).optional()
+});
+var AgentListResponseSchema = z.object({
+  data: z.array(AgentSummarySchema),
+  total: z.number().optional()
+});
+var MentionRequestSchema = z.object({
+  agentName: z.string().optional(),
+  message: z.string(),
+  config: z.record(z.string(), z.unknown()).optional()
+});
+var DirectedMentionResponseSchema = z.object({
+  success: z.boolean(),
+  agentName: z.string(),
+  agentId: z.string(),
+  warning: z.string().optional()
+});
+var AmbientMentionResponseSchema = z.object({
+  success: z.boolean(),
+  mode: z.literal("ambient"),
+  agentCount: z.number(),
+  results: z.array(
+    z.object({
+      agentName: z.string(),
+      status: z.string()
+    })
+  )
+});
+var MentionResponseSchema = z.union([DirectedMentionResponseSchema, AmbientMentionResponseSchema]);
+var TavernQuestSchema = z.object({
+  _id: z.string(),
+  title: z.string(),
+  description: z.string().optional(),
+  status: z.string(),
+  postedBy: z.string(),
+  claimedBy: z.string().optional(),
+  difficulty: z.string().optional(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional()
+});
+var QuestListResponseSchema = z.object({
+  quests: z.array(TavernQuestSchema)
+});
+var CreateQuestRequestSchema = z.object({
+  title: z.string(),
+  description: z.string().optional(),
+  agentId: z.string(),
+  agentName: z.string(),
+  difficulty: z.enum(["easy", "medium", "hard", "epic"]).optional()
+});
+var QuestResponseSchema = z.object({
+  quest: TavernQuestSchema
+});
+var NotebookEntrySchema = z.object({
+  _id: z.string(),
+  title: z.string().optional(),
+  content: z.string().optional(),
+  createdAt: z.string().optional()
+});
+var NotebookResponseSchema = z.object({
+  sessionId: z.string().nullable(),
+  entries: z.array(NotebookEntrySchema)
+});
+var TimedGateSchema = z.object({
+  gateId: z.string(),
+  agentId: z.string(),
+  agentName: z.string(),
+  userId: z.string(),
+  confidence: z.number(),
+  reason: z.string(),
+  createdAt: z.number(),
+  expiresAt: z.number(),
+  delayMs: z.number(),
+  status: z.enum(["pending", "approved", "rejected", "expired", "auto_proceeded"]),
+  resolvedBy: z.enum(["human", "timer"]).optional(),
+  resolvedAt: z.number().optional(),
+  burstId: z.string(),
+  iteration: z.number()
+});
+var GateListResponseSchema = z.object({
+  gates: z.array(TimedGateSchema)
+});
+var GateResolveRequestSchema = z.object({
+  gateId: z.string(),
+  resolution: z.enum(["approve", "reject"])
+});
+var GateResolveResponseSchema = z.object({
+  success: z.boolean(),
+  gate: TimedGateSchema
+});
+var HeartbeatToggleResponseSchema = z.object({
+  success: z.boolean(),
+  enabled: z.boolean(),
+  agentCount: z.number()
+});
+var TriggerHeartbeatResponseSchema = z.object({
+  triggered: z.number(),
+  results: z.array(
+    z.object({
+      agentId: z.string(),
+      agentName: z.string(),
+      status: z.string(),
+      error: z.string().optional()
+    })
+  )
+});
+
+// src/features/tavern/TavernActivityStream.ts
+var TavernActivityStream = class {
+  constructor(onLogEntry) {
+    this.onLogEntry = onLogEntry;
+    this.wsManager = null;
+  }
+  /** Register the WS handler for tavern_heartbeat_log events */
+  registerHandlers(wsManager) {
+    this.dispose();
+    this.wsManager = wsManager;
+    wsManager.onAction("tavern_heartbeat_log", (message) => {
+      const parsed = message;
+      if (!parsed.entry) return;
+      const result = HeartbeatLogEntrySchema.safeParse(parsed.entry);
+      if (result.success) {
+        this.onLogEntry(result.data);
+      }
+    });
+  }
+  /** Unsubscribe from WS events */
+  dispose() {
+    if (this.wsManager) {
+      this.wsManager.offAction("tavern_heartbeat_log");
+      this.wsManager = null;
+    }
+  }
+};
+
+// src/features/tavern/tavernTools.ts
+function createTavernTools(service) {
+  return [
+    createListAgentsTool(service),
+    createCreateAgentTool(service),
+    createEditAgentTool(service),
+    createDeleteAgentTool(service),
+    createMentionTool(service),
+    createListQuestsTool(service),
+    createPostQuestTool(service),
+    createDeleteQuestTool(service),
+    createReadNotebookTool(service),
+    createListGatesTool(service),
+    createResolveGateTool(service),
+    createToggleHeartbeatsTool(service),
+    createTriggerHeartbeatTool(service),
+    createAbortHeartbeatsTool(service),
+    createStatusTool(service)
+  ];
+}
+function createListAgentsTool(service) {
+  return {
+    toolSchema: {
+      name: "tavern_list_agents",
+      description: "List all Tavern agents with their IDs, names, descriptions, and heartbeat status. Use this FIRST to discover agent IDs before using tools that require an agent_id (like tavern_read_notebook or tavern_post_quest).",
+      parameters: {
+        type: "object",
+        properties: {}
+      }
+    },
+    toolFn: async () => {
+      const result = await service.listAgents();
+      return JSON.stringify(result);
+    }
+  };
+}
+function createCreateAgentTool(service) {
+  return {
+    toolSchema: {
+      name: "tavern_create_agent",
+      description: "Create a new Tavern agent with a personality. The agent will be created without heartbeats enabled \u2014 use tavern_toggle_heartbeats after creation to activate autonomous behavior. Personality fields shape how the agent thinks and acts during heartbeats.",
+      parameters: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            description: 'The agent name (e.g. "Spock", "Luna", "Chef Gordon")'
+          },
+          description: {
+            type: "string",
+            description: "A short description of the agent"
+          },
+          system_prompt: {
+            type: "string",
+            description: "System prompt that defines the agent's core behavior and knowledge"
+          },
+          major_motivation: {
+            type: "string",
+            description: 'What primarily drives this agent (e.g. "Exploring the unknown")'
+          },
+          minor_motivation: {
+            type: "string",
+            description: 'Secondary drive (e.g. "Collecting rare artifacts")'
+          },
+          flaw: {
+            type: "string",
+            description: 'A character flaw that creates interesting behavior (e.g. "Overthinks simple problems")'
+          },
+          quirk: {
+            type: "string",
+            description: 'A distinctive behavioral quirk (e.g. "Speaks in nautical metaphors")'
+          },
+          personality_description: {
+            type: "string",
+            description: "Overall personality summary"
+          },
+          personal_mission: {
+            type: "string",
+            description: `The agent's purpose in the tavern (e.g. "Map every corner of the digital realm")`
+          },
+          active_project: {
+            type: "string",
+            description: "What the agent is currently working on"
+          },
+          communication_pattern: {
+            type: "string",
+            description: 'How the agent communicates (e.g. "Formal and precise", "Casual and witty")'
+          },
+          humor_style: {
+            type: "string",
+            description: `The agent's sense of humor (e.g. "Dry wit", "Puns and wordplay")`
+          },
+          backstory_element: {
+            type: "string",
+            description: "A backstory detail that influences behavior"
+          },
+          energy_level: {
+            type: "string",
+            description: 'Default energy level (e.g. "High energy morning person", "Calm and measured")'
+          },
+          core_values: {
+            type: "string",
+            description: 'What the agent values most (e.g. "Truth and transparency")'
+          }
+        },
+        required: ["name"]
+      }
+    },
+    toolFn: async (params) => {
+      const raw = params;
+      const request = CreateAgentRequestSchema.parse({
+        name: raw.name,
+        description: raw.description,
+        systemPrompt: raw.system_prompt,
+        personality: {
+          majorMotivation: raw.major_motivation,
+          minorMotivation: raw.minor_motivation,
+          flaw: raw.flaw,
+          quirk: raw.quirk,
+          description: raw.personality_description,
+          personalMission: raw.personal_mission,
+          activeProject: raw.active_project,
+          communicationPattern: raw.communication_pattern,
+          humorStyle: raw.humor_style,
+          backstoryElement: raw.backstory_element,
+          energyLevel: raw.energy_level,
+          coreValues: raw.core_values
+        }
+      });
+      const result = await service.createAgent(request);
+      return JSON.stringify(result);
+    }
+  };
+}
+function createEditAgentTool(service) {
+  return {
+    toolSchema: {
+      name: "tavern_edit_agent",
+      description: "Update an existing Tavern agent. Can change personality, system prompt, heartbeat config, or any other field. Use this to enable/disable heartbeats for a SINGLE agent (set heartbeat_enabled), or to update personality traits. Only provide fields you want to change \u2014 unspecified fields remain unchanged.",
+      parameters: {
+        type: "object",
+        properties: {
+          agent_id: {
+            type: "string",
+            description: "The MongoDB ObjectId of the agent (get from tavern_list_agents)"
+          },
+          name: { type: "string", description: "New agent name" },
+          description: { type: "string", description: "New description" },
+          system_prompt: { type: "string", description: "New system prompt" },
+          heartbeat_enabled: {
+            type: "boolean",
+            description: "Enable or disable heartbeats for THIS specific agent"
+          },
+          heartbeat_interval_minutes: {
+            type: "number",
+            description: "Heartbeat interval in minutes (default: 3)"
+          },
+          major_motivation: { type: "string", description: "What primarily drives this agent" },
+          minor_motivation: { type: "string", description: "Secondary drive" },
+          flaw: { type: "string", description: "Character flaw" },
+          quirk: { type: "string", description: "Distinctive quirk" },
+          personal_mission: { type: "string", description: "Agent's purpose in the tavern" },
+          active_project: { type: "string", description: "What the agent is currently working on" },
+          communication_pattern: { type: "string", description: "How the agent communicates" },
+          humor_style: { type: "string", description: "Agent's sense of humor" }
+        },
+        required: ["agent_id"]
+      }
+    },
+    toolFn: async (params) => {
+      const raw = params;
+      const agentId = raw.agent_id;
+      const payload = {};
+      if (raw.name !== void 0) payload.name = raw.name;
+      if (raw.description !== void 0) payload.description = raw.description;
+      if (raw.system_prompt !== void 0) payload.systemPrompt = raw.system_prompt;
+      if (raw.heartbeat_enabled !== void 0 || raw.heartbeat_interval_minutes !== void 0) {
+        const hb = {};
+        if (raw.heartbeat_enabled !== void 0) hb.enabled = raw.heartbeat_enabled;
+        if (raw.heartbeat_interval_minutes !== void 0) hb.intervalMinutes = raw.heartbeat_interval_minutes;
+        payload.heartbeatConfig = hb;
+      }
+      const personality = {};
+      if (raw.major_motivation !== void 0) personality.majorMotivation = raw.major_motivation;
+      if (raw.minor_motivation !== void 0) personality.minorMotivation = raw.minor_motivation;
+      if (raw.flaw !== void 0) personality.flaw = raw.flaw;
+      if (raw.quirk !== void 0) personality.quirk = raw.quirk;
+      if (raw.personal_mission !== void 0) personality.personalMission = raw.personal_mission;
+      if (raw.active_project !== void 0) personality.activeProject = raw.active_project;
+      if (raw.communication_pattern !== void 0) personality.communicationPattern = raw.communication_pattern;
+      if (raw.humor_style !== void 0) personality.humorStyle = raw.humor_style;
+      if (Object.keys(personality).length > 0) payload.personality = personality;
+      const request = UpdateAgentRequestSchema.parse(payload);
+      const result = await service.updateAgent(agentId, request);
+      return JSON.stringify(result);
+    }
+  };
+}
+function createDeleteAgentTool(service) {
+  return {
+    toolSchema: {
+      name: "tavern_delete_agent",
+      description: "Permanently delete a Tavern agent. This is irreversible. IMPORTANT: agent_id must be a MongoDB ObjectId from tavern_list_agents.",
+      parameters: {
+        type: "object",
+        properties: {
+          agent_id: {
+            type: "string",
+            description: "The MongoDB ObjectId of the agent to delete"
+          }
+        },
+        required: ["agent_id"]
+      }
+    },
+    toolFn: async (params) => {
+      const { agent_id } = params;
+      await service.deleteAgent(agent_id);
+      return JSON.stringify({ success: true, message: `Agent ${agent_id} deleted` });
+    }
+  };
+}
+function createMentionTool(service) {
+  return {
+    toolSchema: {
+      name: "tavern_mention",
+      description: "Send a message to a specific Tavern agent by name, or broadcast an ambient message to all agents if no agent_name is provided. Use this to talk to agents, ask them questions, give them instructions, or announce something to the whole tavern.",
+      parameters: {
+        type: "object",
+        properties: {
+          agent_name: {
+            type: "string",
+            description: "Name of the agent to mention (omit for ambient broadcast to all agents)"
+          },
+          message: {
+            type: "string",
+            description: "The message to send to the agent(s)"
+          }
+        },
+        required: ["message"]
+      }
+    },
+    toolFn: async (params) => {
+      const { agent_name, message } = params;
+      const result = await service.mentionAgent(agent_name, message);
+      return JSON.stringify(result);
+    }
+  };
+}
+function createListQuestsTool(service) {
+  return {
+    toolSchema: {
+      name: "tavern_list_quests",
+      description: "List all quests on the Tavern quest board. Shows quest title, status, who posted it, and who claimed it.",
+      parameters: {
+        type: "object",
+        properties: {}
+      }
+    },
+    toolFn: async () => {
+      const result = await service.listQuests();
+      return JSON.stringify(result);
+    }
+  };
+}
+function createPostQuestTool(service) {
+  return {
+    toolSchema: {
+      name: "tavern_post_quest",
+      description: "Post a new quest to the Tavern quest board for agents to discover and claim.",
+      parameters: {
+        type: "object",
+        properties: {
+          title: {
+            type: "string",
+            description: "Quest title"
+          },
+          description: {
+            type: "string",
+            description: "Detailed quest description"
+          },
+          agent_id: {
+            type: "string",
+            description: "ID of the agent posting the quest"
+          },
+          agent_name: {
+            type: "string",
+            description: "Name of the agent posting the quest"
+          },
+          difficulty: {
+            type: "string",
+            description: "Quest difficulty level",
+            enum: ["easy", "medium", "hard", "epic"]
+          }
+        },
+        required: ["title", "agent_id", "agent_name"]
+      }
+    },
+    toolFn: async (params) => {
+      const raw = params;
+      const request = CreateQuestRequestSchema.parse({
+        title: raw.title,
+        description: raw.description,
+        agentId: raw.agent_id,
+        agentName: raw.agent_name,
+        difficulty: raw.difficulty
+      });
+      const result = await service.postQuest(request);
+      return JSON.stringify(result);
+    }
+  };
+}
+function createDeleteQuestTool(service) {
+  return {
+    toolSchema: {
+      name: "tavern_delete_quest",
+      description: "Remove a quest from the Tavern quest board by its ID.",
+      parameters: {
+        type: "object",
+        properties: {
+          quest_id: {
+            type: "string",
+            description: "The ID of the quest to delete"
+          }
+        },
+        required: ["quest_id"]
+      }
+    },
+    toolFn: async (params) => {
+      const { quest_id } = params;
+      await service.deleteQuest(quest_id);
+      return JSON.stringify({ success: true });
+    }
+  };
+}
+function createReadNotebookTool(service) {
+  return {
+    toolSchema: {
+      name: "tavern_read_notebook",
+      description: `Read a Tavern agent's activity notebook/history. Shows their recent actions, thoughts, conversations, and quest progress. IMPORTANT: agent_id must be a MongoDB ObjectId (e.g. "6540b58d1f703ade3ea1e82b"), NOT the agent name. Use tavern_list_agents first to get the correct ID.`,
+      parameters: {
+        type: "object",
+        properties: {
+          agent_id: {
+            type: "string",
+            description: "The MongoDB ObjectId of the agent (get this from tavern_list_agents, NOT the agent name)"
+          },
+          limit: {
+            type: "number",
+            description: "Maximum number of entries to return (default: 50)"
+          }
+        },
+        required: ["agent_id"]
+      }
+    },
+    toolFn: async (params) => {
+      const { agent_id, limit } = params;
+      const result = await service.getAgentNotebook(agent_id, limit);
+      return JSON.stringify(result);
+    }
+  };
+}
+function createListGatesTool(service) {
+  return {
+    toolSchema: {
+      name: "tavern_list_gates",
+      description: "List all pending confidence gates in the Tavern. Gates are pause points where agents need human approval to proceed with low-confidence actions.",
+      parameters: {
+        type: "object",
+        properties: {}
+      }
+    },
+    toolFn: async () => {
+      const result = await service.listGates();
+      return JSON.stringify(result);
+    }
+  };
+}
+function createResolveGateTool(service) {
+  return {
+    toolSchema: {
+      name: "tavern_resolve_gate",
+      description: "Approve or reject a pending confidence gate. This lets an agent proceed or stops its current action.",
+      parameters: {
+        type: "object",
+        properties: {
+          gate_id: {
+            type: "string",
+            description: "The ID of the gate to resolve"
+          },
+          resolution: {
+            type: "string",
+            description: "Whether to approve or reject the gate",
+            enum: ["approve", "reject"]
+          }
+        },
+        required: ["gate_id", "resolution"]
+      }
+    },
+    toolFn: async (params) => {
+      const { gate_id, resolution } = params;
+      const result = await service.resolveGate(gate_id, resolution);
+      return JSON.stringify(result);
+    }
+  };
+}
+function createToggleHeartbeatsTool(service) {
+  return {
+    toolSchema: {
+      name: "tavern_toggle_heartbeats",
+      description: "Enable or disable background heartbeats for all Tavern agents. When enabled, agents autonomously think, act, and interact on a schedule.",
+      parameters: {
+        type: "object",
+        properties: {
+          enabled: {
+            type: "boolean",
+            description: "true to enable heartbeats, false to disable"
+          }
+        },
+        required: ["enabled"]
+      }
+    },
+    toolFn: async (params) => {
+      const { enabled } = params;
+      const result = await service.toggleHeartbeats(enabled);
+      return JSON.stringify(result);
+    }
+  };
+}
+function createTriggerHeartbeatTool(service) {
+  return {
+    toolSchema: {
+      name: "tavern_trigger_heartbeat",
+      description: "Manually trigger a heartbeat cycle for all Tavern agents. Useful for testing or forcing immediate agent activity.",
+      parameters: {
+        type: "object",
+        properties: {
+          config: {
+            type: "object",
+            description: 'Optional configuration overrides for the heartbeat. Known keys: preferredModelId (string \u2014 model ID to use), costMode ("low" | "normal" | "high")',
+            additionalProperties: true
+          }
+        }
+      }
+    },
+    toolFn: async (params) => {
+      const { config } = params ?? {};
+      const result = await service.triggerHeartbeat(config);
+      return JSON.stringify(result);
+    }
+  };
+}
+function createAbortHeartbeatsTool(service) {
+  return {
+    toolSchema: {
+      name: "tavern_abort_heartbeats",
+      description: "Emergency stop \u2014 abort all in-flight Tavern agent heartbeats immediately.",
+      parameters: {
+        type: "object",
+        properties: {}
+      }
+    },
+    toolFn: async () => {
+      await service.abortHeartbeats();
+      return JSON.stringify({ success: true, message: "All in-flight heartbeats aborted" });
+    }
+  };
+}
+function createStatusTool(service) {
+  return {
+    toolSchema: {
+      name: "tavern_status",
+      description: "Get a quick overview of the Tavern: agent count, heartbeat status, active quests, and pending gates. Use this for situational awareness before taking action.",
+      parameters: {
+        type: "object",
+        properties: {}
+      }
+    },
+    toolFn: async () => {
+      const [agents, quests, gates] = await Promise.all([
+        service.listAgents(),
+        service.listQuests(),
+        service.listGates()
+      ]);
+      const agentList = agents.data ?? [];
+      const heartbeatEnabled = agentList.filter((a) => a.heartbeatConfig?.enabled);
+      return JSON.stringify({
+        agents: {
+          total: agentList.length,
+          withHeartbeats: heartbeatEnabled.length,
+          names: agentList.map((a) => ({ name: a.name, heartbeat: a.heartbeatConfig?.enabled ?? false }))
+        },
+        quests: {
+          total: quests.quests.length,
+          byStatus: quests.quests.reduce(
+            (acc, q) => {
+              acc[q.status] = (acc[q.status] ?? 0) + 1;
+              return acc;
+            },
+            {}
+          )
+        },
+        gates: {
+          pending: gates.gates.length
+        }
+      });
+    }
+  };
+}
+
+// src/features/tavern/TavernModule.ts
+var ACTION_ICONS = {
+  speech: "\u{1F4AC}",
+  thought: "\u{1F4AD}",
+  memory: "\u{1F9E0}",
+  move: "\u{1F6B6}",
+  reply: "\u{1F4E9}",
+  post_quest: "\u{1F4DC}",
+  claim_quest: "\u2694\uFE0F",
+  complete_quest: "\u2705",
+  tool_use: "\u{1F527}",
+  email: "\u{1F4E7}",
+  gate_paused: "\u23F8\uFE0F",
+  gate_timed: "\u23F3",
+  gate_proceed: "\u25B6\uFE0F",
+  idle: "\u{1F4A4}",
+  intent: "\u{1F3AF}",
+  report: "\u{1F4CB}",
+  credits: "\u{1FA99}",
+  move_decoration: "\u{1F3A8}",
+  yolo_override: "\u26A1"
+};
+var TavernModule = class {
+  constructor(apiClient, onLogEntry, getActivityLog) {
+    this.name = "tavern";
+    this.description = "Interact with autonomous AI agents in the B4M Tavern";
+    this.service = new TavernService(apiClient);
+    this.activityStream = new TavernActivityStream(onLogEntry);
+    this.getActivityLog = getActivityLog;
+  }
+  getTools() {
+    return createTavernTools(this.service);
+  }
+  getSystemPromptSection() {
+    return `## Tavern Integration
+You can interact with autonomous AI agents in the B4M Tavern using tavern_* tools.
+
+IMPORTANT: Many tools require agent IDs (MongoDB ObjectIds like "6540b58d1f703ade3ea1e82b"). Always use tavern_list_agents FIRST to discover agent names and their IDs before using tools that need an agent_id.
+
+Available actions:
+- **tavern_list_agents**: List all agents with their IDs, names, and status \u2014 USE THIS FIRST
+- **tavern_create_agent**: Create a new agent with a personality (heartbeats disabled by default)
+- **tavern_edit_agent**: Update an agent's personality, system prompt, or heartbeat config (per-agent toggle)
+- **tavern_delete_agent**: Permanently delete an agent
+- **tavern_mention**: Talk to a specific agent by name or broadcast to all agents
+- **tavern_list_quests**: View the quest board
+- **tavern_post_quest**: Post a new quest for agents to claim
+- **tavern_delete_quest**: Remove a quest from the board
+- **tavern_read_notebook**: Read an agent's activity history (requires agent ID from tavern_list_agents)
+- **tavern_list_gates**: See pending confidence gates awaiting human approval
+- **tavern_resolve_gate**: Approve or reject a confidence gate
+- **tavern_toggle_heartbeats**: Enable/disable agent background heartbeats
+- **tavern_trigger_heartbeat**: Manually trigger a heartbeat cycle
+- **tavern_abort_heartbeats**: Emergency stop all in-flight heartbeats
+- **tavern_status**: Quick overview of agents, quests, and gates \u2014 good for situational awareness
+
+When the user mentions talking to agents, checking the quest board, or managing the tavern, use these tools.
+Agents have personalities, moods, quests, and memories \u2014 they are autonomous entities, not chatbots.`;
+  }
+  getCommands() {
+    return [
+      {
+        name: "tavern",
+        description: "Show recent Tavern agent activity stream",
+        execute: () => {
+          const activityLog = this.getActivityLog();
+          if (activityLog.length === 0) {
+            console.log("\nTavern Activity: No activity yet.");
+            console.log("  Agents broadcast activity during heartbeats.");
+            console.log('  Try: "trigger a heartbeat cycle" to generate activity.\n');
+            return;
+          }
+          const recentEntries = activityLog.slice(-20);
+          console.log(`
+Tavern Activity (last ${recentEntries.length} of ${activityLog.length} entries):
+`);
+          for (const entry of recentEntries) {
+            const time = new Date(entry.timestamp).toLocaleTimeString();
+            const icon = ACTION_ICONS[entry.action] ?? "\xB7";
+            const target = entry.targetAgentName ? ` \u2192 ${entry.targetAgentName}` : "";
+            const text = entry.text ? `: ${entry.text.slice(0, 120)}${entry.text.length > 120 ? "..." : ""}` : "";
+            console.log(`  ${time}  ${icon} ${entry.agentName}${target} [${entry.action}]${text}`);
+          }
+          console.log("");
+        }
+      }
+    ];
+  }
+  registerWsHandlers(wsManager) {
+    this.activityStream.registerHandlers(wsManager);
+  }
+  dispose() {
+    this.activityStream.dispose();
+  }
+};
+
 // src/index.tsx
 process.removeAllListeners("warning");
 process.on("warning", (warning) => {
@@ -3030,7 +3988,8 @@ function CliApp() {
     sandboxOrchestrator: null,
     wsManager: null,
     checkpointStore: null,
-    additionalDirectories: []
+    additionalDirectories: [],
+    featureRegistry: null
   });
   const [isInitialized, setIsInitialized] = useState12(false);
   const [initError, setInitError] = useState12(null);
@@ -3060,6 +4019,9 @@ function CliApp() {
         })
       );
     }
+    if (state.featureRegistry) {
+      state.featureRegistry.disposeAll();
+    }
     if (state.wsManager) {
       state.wsManager.disconnect();
       setWebSocketToolExecutor(null);
@@ -3082,7 +4044,15 @@ function CliApp() {
     setTimeout(() => {
       process.exit(0);
     }, 100);
-  }, [state.session, state.sessionStore, state.mcpManager, state.agent, state.imageStore, state.wsManager]);
+  }, [
+    state.session,
+    state.sessionStore,
+    state.mcpManager,
+    state.agent,
+    state.imageStore,
+    state.wsManager,
+    state.featureRegistry
+  ]);
   useInput10((input, key) => {
     if (key.escape) {
       const store = useCliStore.getState();
@@ -3549,6 +4519,23 @@ Pull a model: ollama pull qwen3.5`
       }) : null;
       const findDefinitionTool = createFindDefinitionTool();
       const getFileStructureTool = createGetFileStructureTool();
+      const featureRegistry = new FeatureModuleRegistry();
+      if (config.features?.tavern) {
+        featureRegistry.register(
+          new TavernModule(
+            apiClient,
+            (entry) => useCliStore.getState().addTavernLogEntry(entry),
+            () => useCliStore.getState().tavernActivityLog
+          )
+        );
+      }
+      const featureModuleToolNames = featureRegistry.getAllToolNames();
+      if (featureModuleToolNames.length > 0) {
+        registerFeatureModuleTools(featureModuleToolNames);
+      }
+      if (wsManager && featureRegistry.hasModules) {
+        featureRegistry.registerAllWsHandlers(wsManager);
+      }
       const cliTools = [
         agentDelegateTool,
         ...backgroundTools,
@@ -3562,7 +4549,8 @@ Pull a model: ollama pull qwen3.5`
       if (dynamicAgentTool) {
         cliTools.push(dynamicAgentTool);
       }
-      const allTools = [...b4mTools, ...mcpTools, ...cliTools];
+      const featureTools = featureRegistry.getAllTools();
+      const allTools = [...b4mTools, ...mcpTools, ...cliTools, ...featureTools];
       startupLog.push(`\u{1F4C2} Working directory: ${process.cwd()}`);
       if (additionalDirectories.length > 0) {
         startupLog.push(`\u{1F4C1} Additional directories: ${additionalDirectories.length}`);
@@ -3578,8 +4566,12 @@ Pull a model: ollama pull qwen3.5`
       if (dynamicAgentTool) {
         startupLog.push(`\u{1F9EA} Dynamic agent creation enabled (experimental)`);
       }
+      if (featureRegistry.hasModules) {
+        const moduleNames = featureRegistry.getModuleNames().join(", ");
+        startupLog.push(`\u{1F3F0} Feature modules: ${moduleNames} (${featureTools.length} tools)`);
+      }
       logger.debug(
-        `Total tools available to agent: ${allTools.length} (${b4mTools.length} B4M + ${mcpTools.length} MCP + ${cliTools.length} CLI)`
+        `Total tools available to agent: ${allTools.length} (${b4mTools.length} B4M + ${mcpTools.length} MCP + ${cliTools.length} CLI + ${featureTools.length} feature)`
       );
       if (contextResult.globalContext) {
         startupLog.push(`\u{1F4C4} Global context: ${contextResult.globalContext.filename}`);
@@ -3590,13 +4582,15 @@ Pull a model: ollama pull qwen3.5`
       for (const error of contextResult.errors) {
         startupLog.push(`\u26A0\uFE0F  Context file error: ${error}`);
       }
+      const featureModulePrompts = featureRegistry.getSystemPromptSections();
       const cliSystemPrompt = buildCoreSystemPrompt({
         contextContent: contextResult.mergedContent,
         agentStore,
         customCommands: state.customCommandStore.getAllCommands(),
         enableSkillTool,
         enableDynamicAgentCreation: config.preferences.enableDynamicAgentCreation === true,
-        additionalDirectories
+        additionalDirectories,
+        featureModulePrompts: featureModulePrompts || void 0
       });
       const maxIterations = config.preferences.maxIterations === null ? 999999 : config.preferences.maxIterations;
       const agent = new ReActAgent({
@@ -3664,8 +4658,10 @@ Pull a model: ollama pull qwen3.5`
         // WebSocket connection manager (null if using SSE fallback)
         checkpointStore,
         // File change checkpointing for undo/restore
-        additionalDirectories
+        additionalDirectories,
         // Store additional directories for file access
+        featureRegistry
+        // Feature module registry for opt-in modules
       }));
       setStoreSession(newSession);
       const bannerLines = [
@@ -3942,7 +4938,8 @@ Pull a model: ollama pull qwen3.5`
         agentStore: state.agentStore || void 0,
         customCommands: state.customCommandStore.getAllCommands(),
         enableSkillTool: config?.preferences.enableSkillTool !== false,
-        additionalDirectories: state.additionalDirectories
+        additionalDirectories: state.additionalDirectories,
+        featureModulePrompts: state.featureRegistry?.getSystemPromptSections() || void 0
       });
       const contextUsage = tokenCounter2.countSessionTokens(activeSession, systemPrompt);
       if (contextUsage.totalTokens >= threshold) {
@@ -4997,7 +5994,8 @@ No usage data available for the last ${USAGE_DAYS} days.`);
           agentStore: state.agentStore || void 0,
           customCommands: commands,
           enableSkillTool: state.config?.preferences.enableSkillTool !== false,
-          additionalDirectories: state.additionalDirectories
+          additionalDirectories: state.additionalDirectories,
+          featureModulePrompts: state.featureRegistry?.getSystemPromptSections() || void 0
         });
         const usage = tokenCounter2.countSessionTokens(state.session, systemPrompt);
         const totalWithTools = usage.totalTokens + mcpToolsTokens;
@@ -5545,15 +6543,70 @@ Allowed domains (${domains.length}):`);
         console.log("Violation log cleared.");
         break;
       }
-      default:
+      default: {
+        if (state.featureRegistry?.executeCommand(command, args)) {
+          break;
+        }
         console.log(`Unknown command: /${command}`);
         console.log("Type /help for available commands");
+      }
     }
   };
   const handleSaveConfig = async (updatedConfig) => {
     await state.configStore.save(updatedConfig);
     const modelChanged = state.config?.defaultModel !== updatedConfig.defaultModel;
+    const featuresChanged = JSON.stringify(state.config?.features ?? {}) !== JSON.stringify(updatedConfig.features ?? {});
+    let newFeatureRegistry = state.featureRegistry;
+    if (featuresChanged && state.agent) {
+      state.featureRegistry?.disposeAll();
+      clearFeatureModuleTools();
+      newFeatureRegistry = new FeatureModuleRegistry();
+      const apiClient = new ApiClient(getApiUrl(updatedConfig.apiConfig), state.configStore);
+      if (updatedConfig.features?.tavern) {
+        newFeatureRegistry.register(
+          new TavernModule(
+            apiClient,
+            (entry) => useCliStore.getState().addTavernLogEntry(entry),
+            () => useCliStore.getState().tavernActivityLog
+          )
+        );
+      }
+      const newToolNames = newFeatureRegistry.getAllToolNames();
+      if (newToolNames.length > 0) {
+        registerFeatureModuleTools(newToolNames);
+      }
+      if (state.wsManager && newFeatureRegistry.hasModules) {
+        newFeatureRegistry.registerAllWsHandlers(state.wsManager);
+      }
+      const agentContext = state.agent.context;
+      const oldFeatureToolNames = new Set(state.featureRegistry?.getAllToolNames() ?? []);
+      const baseTools = agentContext.tools.filter((t) => !oldFeatureToolNames.has(t.toolSchema.name));
+      const newFeatureTools = newFeatureRegistry.getAllTools();
+      agentContext.tools = [...baseTools, ...newFeatureTools];
+      const newFeaturePrompts = newFeatureRegistry.getSystemPromptSections();
+      agentContext.systemPrompt = buildCoreSystemPrompt({
+        contextContent: state.contextContent,
+        agentStore: state.agentStore || void 0,
+        customCommands: state.customCommandStore.getAllCommands(),
+        enableSkillTool: updatedConfig.preferences.enableSkillTool !== false,
+        enableDynamicAgentCreation: updatedConfig.preferences.enableDynamicAgentCreation === true,
+        additionalDirectories: state.additionalDirectories,
+        featureModulePrompts: newFeaturePrompts || void 0
+      });
+      const moduleNames = newFeatureRegistry.getModuleNames();
+      if (moduleNames.length > 0) {
+        console.error(`
+\x1B[36m\u{1F3F0} Feature modules hot-reloaded: ${moduleNames.join(", ")}\x1B[0m`);
+      } else {
+        console.error(`
+\x1B[36m\u{1F3F0} Feature modules disabled\x1B[0m`);
+      }
+    }
     setState((prev) => {
+      const updates = { config: updatedConfig };
+      if (featuresChanged) {
+        updates.featureRegistry = newFeatureRegistry;
+      }
       if (modelChanged && prev.session) {
         const updatedSession = {
           ...prev.session,
@@ -5564,9 +6617,9 @@ Allowed domains (${domains.length}):`);
         if (prev.agent) {
           prev.agent.context.model = updatedConfig.defaultModel;
         }
-        return { ...prev, config: updatedConfig, session: updatedSession };
+        return { ...prev, ...updates, session: updatedSession };
       }
-      return { ...prev, config: updatedConfig };
+      return { ...prev, ...updates };
     });
     if (modelChanged && state.agent) {
       const backend = state.agent.context.llm;
@@ -5662,7 +6715,11 @@ Allowed domains (${domains.length}):`);
   if (!isInitialized) {
     return /* @__PURE__ */ React22.createElement(Box21, { flexDirection: "column", padding: 1 }, /* @__PURE__ */ React22.createElement(Text21, null, "\u{1F680} Initializing..."));
   }
-  const allCommands = mergeCommands(state.customCommandStore.getAllCommands());
+  const featureCommandDefs = (state.featureRegistry?.getAllCommands() ?? []).map((cmd) => ({
+    name: cmd.name,
+    description: cmd.description
+  }));
+  const allCommands = mergeCommands(state.customCommandStore.getAllCommands(), featureCommandDefs);
   return /* @__PURE__ */ React22.createElement(
     App,
     {