@bike4mind/cli 0.2.55 → 0.2.56-feat-cli-tavern-integration.21361

package/dist/{chunk-524RAWPN.js → chunk-JV4GPGBC.js}

@@ -397,6 +397,9 @@ var CliConfigSchema = z.object({
     disabled: z.array(z.string()),
     config: z.record(z.string(), z.any())
   }),
+  features: z.object({
+    tavern: z.boolean().optional()
+  }).optional().prefault({}),
   trustedTools: z.array(z.string()).optional().prefault([]),
   sandbox: SandboxConfigSchema.optional(),
   additionalDirectories: z.array(z.string()).optional().prefault([])

package/dist/{chunk-SA2GRZGG.js → chunk-PJ3VATSD.js}

@@ -23,7 +23,7 @@ import {
 import {
   ConfigStore,
   logger
-} from "./chunk-524RAWPN.js";
+} from "./chunk-JV4GPGBC.js";
 import {
   ALERT_THRESHOLDS,
   AiEvents,
@@ -2381,6 +2381,7 @@ function buildCoreSystemPrompt(contextSection, config) {
   let skillsSection = "";
   let dynamicAgentSection = "";
   let directoriesSection = "";
+  let featureModulesSection = "";
   if (typeof contextSection === "string") {
     projectContextSection = contextSection;
     if (config) {
@@ -2393,6 +2394,9 @@ function buildCoreSystemPrompt(contextSection, config) {
       if (config.enableDynamicAgentCreation) {
         dynamicAgentSection = buildDynamicAgentPromptSection();
       }
+      if (config.featureModulePrompts) {
+        featureModulesSection = config.featureModulePrompts;
+      }
     }
   } else if (contextSection && typeof contextSection === "object") {
     config = contextSection;
@@ -2429,6 +2433,9 @@ To access files in additional directories, pass the full path to the 'dir_path'
 
 When the user asks about content in an additional directory, search there first using the dir_path parameter.`;
     }
+    if (config.featureModulePrompts) {
+      featureModulesSection = config.featureModulePrompts;
+    }
   }
   return `You are an autonomous AI assistant with access to tools. Your job is to help users by taking action and solving problems proactively.
 
@@ -2518,7 +2525,7 @@ EXAMPLES:
 - "what packages installed?" \u2192 ${TOOL_GLOB_FILES} "**/package.json" \u2192 ${TOOL_FILE_READ}
 - "find all components using React hooks" \u2192 ${TOOL_SUBAGENT_DELEGATE}(task="find all components using React hooks", type="explore")
 
-Remember: Use context from previous messages to understand follow-up questions.${directoriesSection}${projectContextSection}${skillsSection}`;
+Remember: Use context from previous messages to understand follow-up questions.${directoriesSection}${projectContextSection}${skillsSection}${featureModulesSection}`;
 }
 function buildDynamicAgentPromptSection() {
   return `
@@ -2610,6 +2617,18 @@ var ServerToolExecutor = class {
 
 // src/llm/ToolRouter.ts
 var wsToolExecutor = null;
+var featureModuleTools = /* @__PURE__ */ new Set();
+function registerFeatureModuleTools(toolNames) {
+  for (const name of toolNames) {
+    featureModuleTools.add(name);
+  }
+}
+function clearFeatureModuleTools() {
+  featureModuleTools.clear();
+}
+function isFeatureModuleTool(toolName) {
+  return featureModuleTools.has(toolName);
+}
 function setWebSocketToolExecutor(executor) {
   wsToolExecutor = executor;
 }
@@ -2647,7 +2666,7 @@ async function executeTool(toolName, input, apiClient, localToolFn) {
     logger.debug(`[ToolRouter] Routing ${toolName} to server via HTTP`);
     const executor = new ServerToolExecutor(apiClient);
     return await executor.executeTool(toolName, input);
-  } else if (isLocalTool(toolName)) {
+  } else if (isLocalTool(toolName) || isFeatureModuleTool(toolName)) {
     logger.debug(`[ToolRouter] Executing ${toolName} locally`);
     if (!localToolFn) {
       throw new Error(`Local tool ${toolName} has no implementation`);
@@ -15423,7 +15442,7 @@ function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, a
       if (!permissionManager.needsPermission(toolName, { isSandboxed })) {
         return executeAndRecord();
       }
-      const { useCliStore } = await import("./store-X5LEOSGZ.js");
+      const { useCliStore } = await import("./store-CAB6BV3P.js");
       if (useCliStore.getState().autoAcceptEdits) {
         return executeAndRecord();
       }
@@ -19656,6 +19675,8 @@ export {
   isReadOnlyTool,
   buildSkillsPromptSection,
   buildCoreSystemPrompt,
+  registerFeatureModuleTools,
+  clearFeatureModuleTools,
   setWebSocketToolExecutor,
   ALWAYS_DENIED_FOR_AGENTS,
   DEFAULT_MAX_ITERATIONS,

package/dist/{chunk-25UR2PLZ.js → chunk-SDMU65DA.js}

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.55",
+  version: "0.2.56-feat-cli-tavern-integration.21361+2f1552bbd",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -73,6 +73,7 @@ var package_default = {
     diff: "^8.0.2",
     dotenv: "^17.0.0",
     "eventsource-parser": "^3.0.6",
+    exceljs: "^4.4.0",
     fdir: "^6.5.0",
     "file-type": "^18.7.0",
     "fuse.js": "^7.1.0",
@@ -117,11 +118,11 @@ var package_default = {
     zustand: "^4.5.4"
   },
   devDependencies: {
-    "@bike4mind/agents": "0.2.1",
-    "@bike4mind/common": "2.70.1",
-    "@bike4mind/mcp": "1.33.15",
-    "@bike4mind/services": "2.64.3",
-    "@bike4mind/utils": "2.15.9",
+    "@bike4mind/agents": "0.2.2-feat-cli-tavern-integration.21361+2f1552bbd",
+    "@bike4mind/common": "2.70.2-feat-cli-tavern-integration.21361+2f1552bbd",
+    "@bike4mind/mcp": "1.33.16-feat-cli-tavern-integration.21361+2f1552bbd",
+    "@bike4mind/services": "2.64.4-feat-cli-tavern-integration.21361+2f1552bbd",
+    "@bike4mind/utils": "2.15.10-feat-cli-tavern-integration.21361+2f1552bbd",
     "@types/better-sqlite3": "^7.6.13",
     "@types/jsonwebtoken": "^9.0.4",
     "@types/node": "^22.9.0",
@@ -138,7 +139,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.1"
   },
-  gitHead: "dfc4dccb344f081dd2c87bc16fb2d27f70c02844"
+  gitHead: "2f1552bbd1fd89923637cbcf2a6e40b729437a2d"
 };
 
 // src/utils/updateChecker.ts

package/dist/{chunk-G2LYCVZJ.js → chunk-Y4WOJJM3.js}

@@ -128,7 +128,14 @@ var useCliStore = create((set) => ({
   clearCompletedGroupNotifications: () => set({ completedGroupNotifications: [] }),
   // Pending background trigger
   pendingBackgroundTrigger: false,
-  setPendingBackgroundTrigger: (pending) => set({ pendingBackgroundTrigger: pending })
+  setPendingBackgroundTrigger: (pending) => set({ pendingBackgroundTrigger: pending }),
+  // Tavern activity log (capped at 200 entries)
+  tavernActivityLog: [],
+  addTavernLogEntry: (entry) => set((state) => {
+    const log = [...state.tavernActivityLog, entry];
+    return { tavernActivityLog: log.length > 200 ? log.slice(-200) : log };
+  }),
+  clearTavernActivityLog: () => set({ tavernActivityLog: [] })
 }));
 var selectActiveBackgroundAgents = (state) => state.backgroundAgents.filter((j) => isActiveStatus(j.status));
 var selectCompletedBackgroundAgents = (state) => state.backgroundAgents.filter((j) => !isActiveStatus(j.status));

package/dist/commands/doctorCommand.js

@@ -3,7 +3,7 @@ import {
   fetchLatestVersion,
   forceCheckForUpdate,
   package_default
-} from "../chunk-25UR2PLZ.js";
+} from "../chunk-SDMU65DA.js";
 
 // src/commands/doctorCommand.ts
 import { execSync } from "child_process";

package/dist/commands/headlessCommand.js

@@ -36,7 +36,7 @@ import {
   isReadOnlyTool,
   loadContextFiles,
   setWebSocketToolExecutor
-} from "../chunk-SA2GRZGG.js";
+} from "../chunk-PJ3VATSD.js";
 import "../chunk-BDQBOLYG.js";
 import "../chunk-XACIOJZ7.js";
 import "../chunk-GQGOWACU.js";
@@ -48,7 +48,7 @@ import "../chunk-BPFEGDC7.js";
 import {
   ConfigStore,
   logger
-} from "../chunk-524RAWPN.js";
+} from "../chunk-JV4GPGBC.js";
 import "../chunk-I5ZF2OVL.js";
 import {
   DEFAULT_SANDBOX_CONFIG

package/dist/commands/mcpCommand.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   ConfigStore
-} from "../chunk-524RAWPN.js";
+} from "../chunk-JV4GPGBC.js";
 import "../chunk-I5ZF2OVL.js";
 import "../chunk-4BIBE3J7.js";
 

package/dist/commands/updateCommand.js

@@ -2,7 +2,7 @@
 import {
   forceCheckForUpdate,
   package_default
-} from "../chunk-25UR2PLZ.js";
+} from "../chunk-SDMU65DA.js";
 
 // src/commands/updateCommand.ts
 import { execSync } from "child_process";

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-SA2GRZGG.js";
+} from "./chunk-PJ3VATSD.js";
 import "./chunk-BDQBOLYG.js";
 import "./chunk-XACIOJZ7.js";
 import "./chunk-GQGOWACU.js";
@@ -60,15 +62,15 @@ import "./chunk-BPFEGDC7.js";
 import {
   ConfigStore,
   logger
-} from "./chunk-524RAWPN.js";
+} from "./chunk-JV4GPGBC.js";
 import {
   checkForUpdate,
   package_default
-} from "./chunk-25UR2PLZ.js";
+} from "./chunk-SDMU65DA.js";
 import {
   selectActiveBackgroundAgents,
   useCliStore
-} from "./chunk-G2LYCVZJ.js";
+} from "./chunk-Y4WOJJM3.js";
 import {
   CREDIT_DEDUCT_TRANSACTION_TYPES,
   ChatModels
@@ -1420,6 +1422,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;
@@ -1431,8 +1446,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 {
@@ -2681,6 +2703,599 @@ 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);
+    }
+  }
+  /** 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 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=${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 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.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),
+    createMentionTool(service),
+    createListQuestsTool(service),
+    createPostQuestTool(service),
+    createDeleteQuestTool(service),
+    createReadNotebookTool(service),
+    createListGatesTool(service),
+    createResolveGateTool(service),
+    createToggleHeartbeatsTool(service),
+    createTriggerHeartbeatTool(service),
+    createAbortHeartbeatsTool(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 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 (e.g. preferredModelId, costMode)",
+            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" });
+    }
+  };
+}
+
+// src/features/tavern/TavernModule.ts
+var TavernModule = class {
+  constructor(apiClient, onLogEntry) {
+    this.name = "tavern";
+    this.description = "Interact with autonomous AI agents in the B4M Tavern";
+    this.service = new TavernService(apiClient);
+    this.activityStream = new TavernActivityStream(onLogEntry);
+  }
+  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_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
+
+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.`;
+  }
+  registerWsHandlers(wsManager) {
+    this.activityStream.registerHandlers(wsManager);
+  }
+  dispose() {
+    this.activityStream.dispose();
+  }
+};
+
 // src/index.tsx
 process.removeAllListeners("warning");
 process.on("warning", (warning) => {
@@ -2720,7 +3335,8 @@ function CliApp() {
     sandboxOrchestrator: null,
     wsManager: null,
     checkpointStore: null,
-    additionalDirectories: []
+    additionalDirectories: [],
+    featureRegistry: null
   });
   const [isInitialized, setIsInitialized] = useState12(false);
   const [initError, setInitError] = useState12(null);
@@ -2750,6 +3366,9 @@ function CliApp() {
         })
       );
     }
+    if (state.featureRegistry) {
+      state.featureRegistry.disposeAll();
+    }
     if (state.wsManager) {
       state.wsManager.disconnect();
       setWebSocketToolExecutor(null);
@@ -2772,7 +3391,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();
@@ -3199,6 +3826,21 @@ 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);
+          })
+        );
+      }
+      const featureModuleToolNames = featureRegistry.getAllToolNames();
+      if (featureModuleToolNames.length > 0) {
+        registerFeatureModuleTools(featureModuleToolNames);
+      }
+      if (wsManager && featureRegistry.hasModules) {
+        featureRegistry.registerAllWsHandlers(wsManager);
+      }
       const cliTools = [
         agentDelegateTool,
         ...backgroundTools,
@@ -3212,7 +3854,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}`);
@@ -3228,8 +3871,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}`);
@@ -3240,13 +3887,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({
@@ -3314,8 +3963,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 = [
@@ -3592,7 +4243,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) {
@@ -4647,7 +5299,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;
@@ -5203,7 +5856,56 @@ Allowed domains (${domains.length}):`);
   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);
+          })
+        );
+      }
+      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,
@@ -5214,9 +5916,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;

package/dist/{store-X5LEOSGZ.js → store-CAB6BV3P.js}

@@ -3,7 +3,7 @@ import {
   selectActiveBackgroundAgents,
   selectCompletedBackgroundAgents,
   useCliStore
-} from "./chunk-G2LYCVZJ.js";
+} from "./chunk-Y4WOJJM3.js";
 export {
   selectActiveBackgroundAgents,
   selectCompletedBackgroundAgents,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bike4mind/cli",
-  "version": "0.2.55",
+  "version": "0.2.56-feat-cli-tavern-integration.21361+2f1552bbd",
   "type": "module",
   "description": "Interactive CLI tool for Bike4Mind with ReAct agents",
   "license": "UNLICENSED",
@@ -70,6 +70,7 @@
     "diff": "^8.0.2",
     "dotenv": "^17.0.0",
     "eventsource-parser": "^3.0.6",
+    "exceljs": "^4.4.0",
     "fdir": "^6.5.0",
     "file-type": "^18.7.0",
     "fuse.js": "^7.1.0",
@@ -114,11 +115,11 @@
     "zustand": "^4.5.4"
   },
   "devDependencies": {
-    "@bike4mind/agents": "0.2.1",
-    "@bike4mind/common": "2.70.1",
-    "@bike4mind/mcp": "1.33.15",
-    "@bike4mind/services": "2.64.3",
-    "@bike4mind/utils": "2.15.9",
+    "@bike4mind/agents": "0.2.2-feat-cli-tavern-integration.21361+2f1552bbd",
+    "@bike4mind/common": "2.70.2-feat-cli-tavern-integration.21361+2f1552bbd",
+    "@bike4mind/mcp": "1.33.16-feat-cli-tavern-integration.21361+2f1552bbd",
+    "@bike4mind/services": "2.64.4-feat-cli-tavern-integration.21361+2f1552bbd",
+    "@bike4mind/utils": "2.15.10-feat-cli-tavern-integration.21361+2f1552bbd",
     "@types/better-sqlite3": "^7.6.13",
     "@types/jsonwebtoken": "^9.0.4",
     "@types/node": "^22.9.0",
@@ -135,5 +136,5 @@
   "optionalDependencies": {
     "@vscode/ripgrep": "^1.17.1"
   },
-  "gitHead": "dfc4dccb344f081dd2c87bc16fb2d27f70c02844"
+  "gitHead": "2f1552bbd1fd89923637cbcf2a6e40b729437a2d"
 }