@hailer/mcp 1.1.11 → 1.1.12

package/.mcp.json

@@ -5,9 +5,9 @@
       "command": "npx",
       "args": [
         "mcp-remote",
-        "http://localhost:3031/api/mcp?apiKey=unique-api-key-for-this-agent"
+        "http://localhost:3030/api/mcp?apiKey=unique-api-key-for-this-agent"
       ],
       "env": {}
     }
   }
-}
+}

package/.opencode/agent/agent-helga-workflow-config.md

@@ -1,7 +1,7 @@
 ---
 name: agent-helga-workflow-config
 description: Manages Hailer workspace configuration as infrastructure-as-code using SDK v0.8.4.
-model: sonnet
+model: anthropic/claude-sonnet-4-5
 tools:
   bash: true
   read: true
@@ -53,7 +53,6 @@ For on-demand skills, the orchestrator will say "Load skill X" — use the Skill
 11. **ACTIVITYLINK FIELDS** - data must be plain string array: `["workflowId"]` NOT `[{workflowId: "..."}]`.
 12. **NUMBER FIELDS** - Type: `numeric` (not number).
 13. **FIELD TYPES ARE IMMUTABLE** - Cannot change field type via API. To change text→number: create new field, migrate data, delete old field. Or change in Hailer UI manually.
-14. **CANNOT RENAME WORKFLOWS** - Workflow names cannot be changed via SDK. To "rename": create new workflow with desired name, migrate data, delete old workflow. Or rename in Hailer UI manually.
 
 **Delegation to specialists:**
 - For insight SQL query design → delegate to Viktor (after creating insight entry in insights.ts)

package/.opencode/opencode.json

@@ -17,5 +17,12 @@
     "external_directory": "ask",
     "webfetch": "ask",
     "websearch": "ask"
+  },
+  "mcp": {
+    "hailer": {
+      "type": "remote",
+      "url": "http://localhost:3030/api/mcp?apiKey=unique-api-key-for-this-agent",
+      "enabled": true
+    }
   }
 }

package/CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.10] - 25-02-2026
+
+### Added
+
+- **OpenCode MCP support:** Added `.opencode/opencode.json` with Hailer MCP server configuration
+- **Dynamic port patching for OpenCode:** On server startup, `.opencode/opencode.json` is now auto-updated with the actual port (alongside the existing `.mcp.json` patching), so both Claude Code and OpenCode always connect to the right server
+
 ## [1.1.7] - 18-02-2026
 
 ### Fix

package/SESSION-HANDOFF.md

@@ -0,0 +1,68 @@
+# Session Handoff
+
+**Last Updated:** 2026-03-04
+
+## What Was Done
+
+### System Prompt — Full End-to-End Wiring
+Wired `systemPrompt` field from Agent Directory through the entire bot pipeline:
+
+- **`src/bot-config/constants.ts`** — added `FIELD_KEY_SYSTEM_PROMPT`
+- **`src/bot-config/context.ts`** — `BotSchema.fields.systemPrompt`, `BotCredentials.systemPrompt`, schema discovery, `extractCredentials()`
+- **`src/bot-config/webhooks.ts`** — extract systemPrompt in `extractCredentialsFromActivity()`
+- **`src/bot-config/loader.ts`** — `BotConfigFile` types + `saveBotConfig()` includes systemPrompt
+- **`src/bot/bot-config.ts`** — `BotConfig.systemPrompt`, reads from `orchestrator.systemPrompt`
+- **`src/bot/bot-manager.ts`** — `BotUpdateEntry.systemPrompt`, passes to Bot; smart restart logic: if only systemPrompt changed (credentials same) → `bot.updateSystemPrompt()` without restart
+- **`src/bot/bot.ts`** — `_systemPrompt` instance field (hot-swappable), `updateSystemPrompt()` public method, `buildSystemPrompt()` uses custom prompt + always appends `<bot-identity>` + `<workspace-context>`
+- **`src/commands/seed-config.ts`** — `extractSystemPromptFromActivity()`, wired into orchestrator + specialist output
+- **`src/mcp/webhook-handler.ts`** — `BotEntry.systemPrompt`, `WorkspaceConfig.orchestrator.systemPrompt`, extracts from webhook payload
+
+### System Prompt Design
+- Custom prompt from AI Hub used as full body; `{wsName}`, `{userId}`, `{botName}` substituted at runtime
+- `<bot-identity>` and `<workspace-context>` always appended by bot — never stored
+- Workspace-isolated: each `Bot` instance has own `_systemPrompt`, `BotManager.bots` Map keyed by workspaceId
+- Phase change → full restart picks up new prompt from config file
+- Field edit → webhook fires (with delay) → `handleBotConfigWebhook()` → `updateSystemPrompt()` (no restart)
+
+## Current Work
+
+### Uncommitted — All System Prompt Changes
+10 files modified, compiles clean (`tsc --noEmit` passes). Not yet committed or pushed.
+
+## Next Steps
+
+1. **Commit the system prompt wiring** — all 10 files are ready
+2. **Test end-to-end**: edit prompt in AI Hub → wait for webhook → verify bot uses new prompt
+3. **Cloudflare** — user mentioned needing this (for remote MCP / public webhook URL). See `docs/prd-remote-mcp-server.md` and `docs/prd-remote-mcp-connector.md`
+4. **`activityId` passthrough** (optional improvement) — pass orchestrator's `activityId` into Bot so it can subscribe to `activities.updated` socket signal for instant prompt updates (vs waiting for webhook)
+
+## Key Decisions
+
+- **Hot-swap without restart**: Only credentials change triggers bot restart; systemPrompt-only changes apply live via `updateSystemPrompt()`
+- **Workspace isolation**: Guaranteed by `Map<workspaceId, Bot>` — webhook `cid` field routes to correct bot instance
+- **Webhook-driven updates**: Phase change → webhook (requires public URL). Field-only changes → webhook fires with delay. Socket `activities.updated` would be instant but requires `activityId` passthrough (not yet done)
+- **Prompt structure**: Custom prompt replaces the rules section; `<bot-identity>` + `<workspace-context>` always runtime-injected
+
+## Files Modified (uncommitted)
+
+- `src/bot-config/constants.ts` — FIELD_KEY_SYSTEM_PROMPT
+- `src/bot-config/context.ts` — BotSchema, BotCredentials, discovery, extractCredentials
+- `src/bot-config/loader.ts` — BotConfigFile types + saveBotConfig
+- `src/bot-config/webhooks.ts` — extractCredentialsFromActivity
+- `src/bot/bot-config.ts` — BotConfig + loadBotConfigs
+- `src/bot/bot-manager.ts` — BotUpdateEntry, smart restart, updateSystemPrompt call
+- `src/bot/bot.ts` — _systemPrompt field, updateSystemPrompt(), buildSystemPrompt(), email/password getters
+- `src/commands/seed-config.ts` — extractSystemPromptFromActivity + wired into output
+- `src/mcp/webhook-handler.ts` — BotEntry, WorkspaceConfig types + extraction
+
+## Context to Preserve
+
+- Agent Directory workflow ID: `69885261c432a499a35313b6`
+- Deployed phase: `8fa543c69749ab4e8f9e3967`, Retired phase: `df66a80fe7cfde1c3b928038`
+- AI Hub app: `695e3665701ef8e3824beebe`, marketplace targetId: `698351e8dda756e689368b60`
+- `systemPrompt` field key must be exactly `systemPrompt` (camelCase) — field type: textarea
+- **seed-config.ts is an independent copy** of field extraction — NOT shared with context.ts. Always update both when adding new Agent Directory fields
+- **Two bot-config readers**: `src/bot-config/loader.ts` (BotContext/webhook path) AND `src/bot/bot-config.ts` (BotManager startup path) — both need updating
+- **webhook-handler.ts has its own local types** (BotEntry, WorkspaceConfig) — update independently
+- Webhook fires on phase changes; field edits may have delay before webhook triggers
+- `app-edit-guard --agent-on` does NOT propagate to subagents — do ai-hub edits directly

package/dist/bot/bot-config.d.ts

@@ -5,11 +5,13 @@
  * Extracts orchestrator credentials into a flat BotConfig interface.
  */
 export interface BotConfig {
+    activityId: string;
     workspaceId: string;
     workspaceName: string;
     email: string;
     password: string;
     displayName?: string;
+    systemPrompt?: string;
     enabled: boolean;
     apiHost: string;
 }

package/dist/bot/bot-config.js

@@ -68,21 +68,43 @@ function loadBotConfigs() {
         try {
             const filePath = path.join(configDir, file);
             const raw = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            // Load orchestrator
             const orch = raw.orchestrator;
-            const hasCredentials = !!orch?.email && !!orch?.password;
-            configs.push({
-                workspaceId: raw.workspaceId,
-                workspaceName: raw.workspaceName,
-                email: orch?.email ?? '',
-                password: orch?.password ?? '',
-                displayName: orch?.displayName,
-                enabled: hasCredentials,
-                apiHost: getApiHost(),
-            });
+            if (orch?.email && orch?.password) {
+                configs.push({
+                    activityId: orch.activityId || '',
+                    workspaceId: raw.workspaceId,
+                    workspaceName: raw.workspaceName,
+                    email: orch.email,
+                    password: orch.password,
+                    displayName: orch.displayName,
+                    systemPrompt: orch.systemPrompt,
+                    enabled: true,
+                    apiHost: getApiHost(),
+                });
+            }
+            // Load specialists
+            if (Array.isArray(raw.specialists)) {
+                for (const spec of raw.specialists) {
+                    if (spec?.email && spec?.password && spec?.enabled !== false) {
+                        configs.push({
+                            activityId: spec.activityId || '',
+                            workspaceId: raw.workspaceId,
+                            workspaceName: raw.workspaceName,
+                            email: spec.email,
+                            password: spec.password,
+                            displayName: spec.displayName,
+                            systemPrompt: spec.systemPrompt,
+                            enabled: true,
+                            apiHost: getApiHost(),
+                        });
+                    }
+                }
+            }
             logger.debug('Loaded bot config', {
                 workspaceId: raw.workspaceId,
                 workspaceName: raw.workspaceName,
-                enabled: hasCredentials,
+                botCount: configs.filter(c => c.workspaceId === raw.workspaceId).length,
             });
         }
         catch (error) {
@@ -124,6 +146,7 @@ function saveBotConfig(config) {
             email: config.email,
             password: config.password,
             displayName: config.displayName,
+            systemPrompt: config.systemPrompt,
         } : null,
         specialists: existing.specialists ?? [],
         lastSynced: new Date().toISOString(),

package/dist/bot/bot-manager.d.ts

@@ -7,23 +7,31 @@
 import { ToolRegistry } from '../mcp/tool-registry';
 import { BotConfig } from './bot-config';
 interface BotUpdateEntry {
+    activityId: string;
     email: string;
     password: string;
     botType: string;
     enabled: boolean;
     displayName?: string;
+    systemPrompt?: string;
 }
 export declare class BotManager {
     private toolRegistry;
     private anthropicApiKey;
+    /** Key: activityId → Bot instance */
     private bots;
+    /** Key: workspaceId → Set of activityIds (for cross-bot awareness) */
+    private workspaceBots;
     private apiHost;
     constructor(toolRegistry: ToolRegistry, anthropicApiKey: string);
+    /** Get all bot userIds in a workspace (for self-message guard) */
+    getBotUserIdsForWorkspace(workspaceId: string): Set<string>;
     startAll(): Promise<void>;
     startBot(config: BotConfig): Promise<void>;
-    stopBot(workspaceId: string): Promise<void>;
+    stopBot(botKey: string, workspaceId?: string): Promise<void>;
     stopAll(): Promise<void>;
     getStatus(): Array<{
+        activityId: string;
         workspaceId: string;
         connected: boolean;
         displayName: string;
@@ -31,8 +39,8 @@ export declare class BotManager {
     getBotCount(): number;
     /**
      * Handle hot reload from webhook updates.
-     * Only processes orchestrator bots. Workspace-isolated — only touches
-     * the bot for the specified workspaceId, never affects other workspaces.
+     * Supports all bot types. Routes by activityId so multiple bots
+     * can run in the same workspace independently.
      */
     handleBotUpdate(workspaceId: string, bot: BotUpdateEntry, action: 'add' | 'update' | 'remove'): Promise<void>;
 }

package/dist/bot/bot-manager.js

@@ -14,13 +14,29 @@ const logger = (0, logger_1.createLogger)({ component: 'bot-manager' });
 class BotManager {
     toolRegistry;
     anthropicApiKey;
+    /** Key: activityId → Bot instance */
     bots = new Map();
+    /** Key: workspaceId → Set of activityIds (for cross-bot awareness) */
+    workspaceBots = new Map();
     apiHost;
     constructor(toolRegistry, anthropicApiKey) {
         this.toolRegistry = toolRegistry;
         this.anthropicApiKey = anthropicApiKey;
         this.apiHost = process.env.BOT_API_BASE_URL || 'https://api.hailer.com';
     }
+    /** Get all bot userIds in a workspace (for self-message guard) */
+    getBotUserIdsForWorkspace(workspaceId) {
+        const ids = new Set();
+        const activityIds = this.workspaceBots.get(workspaceId);
+        if (activityIds) {
+            for (const actId of activityIds) {
+                const bot = this.bots.get(actId);
+                if (bot?.botUserId)
+                    ids.add(bot.botUserId);
+            }
+        }
+        return ids;
+    }
     async startAll() {
         const configs = (0, bot_config_1.loadBotConfigs)();
         const enabled = configs.filter(c => c.enabled);
@@ -37,11 +53,13 @@ class BotManager {
         logger.debug('Bot startup complete', { succeeded, failed });
     }
     async startBot(config) {
-        if (this.bots.has(config.workspaceId)) {
-            logger.warn('Bot already running', { workspaceId: config.workspaceId });
+        const botKey = config.activityId || config.workspaceId; // fallback for legacy configs
+        if (this.bots.has(botKey)) {
+            logger.warn('Bot already running', { activityId: botKey, workspaceId: config.workspaceId });
             return;
         }
         logger.debug('Starting bot', {
+            activityId: botKey,
             workspaceId: config.workspaceId,
             workspace: config.workspaceName,
         });
@@ -52,32 +70,50 @@ class BotManager {
             anthropicApiKey: this.anthropicApiKey,
             toolRegistry: this.toolRegistry,
             workspaceId: config.workspaceId,
+            systemPrompt: config.systemPrompt,
+            botManager: this,
         });
         await bot.start();
-        this.bots.set(config.workspaceId, bot);
-        logger.debug('Bot started', { workspaceId: config.workspaceId });
+        this.bots.set(botKey, bot);
+        // Track in workspace lookup
+        if (!this.workspaceBots.has(config.workspaceId)) {
+            this.workspaceBots.set(config.workspaceId, new Set());
+        }
+        this.workspaceBots.get(config.workspaceId).add(botKey);
+        logger.debug('Bot started', { activityId: botKey, workspaceId: config.workspaceId });
     }
-    async stopBot(workspaceId) {
-        const bot = this.bots.get(workspaceId);
+    async stopBot(botKey, workspaceId) {
+        const bot = this.bots.get(botKey);
         if (!bot)
             return;
         await bot.stop();
-        this.bots.delete(workspaceId);
-        logger.debug('Bot stopped', { workspaceId });
+        this.bots.delete(botKey);
+        // Clean up workspace tracking
+        if (workspaceId) {
+            const wsSet = this.workspaceBots.get(workspaceId);
+            if (wsSet) {
+                wsSet.delete(botKey);
+                if (wsSet.size === 0)
+                    this.workspaceBots.delete(workspaceId);
+            }
+        }
+        logger.debug('Bot stopped', { activityId: botKey, workspaceId });
     }
     async stopAll() {
         logger.debug('Stopping all bots', { count: this.bots.size });
-        await Promise.allSettled(Array.from(this.bots.entries()).map(async ([wsId, bot]) => {
+        await Promise.allSettled(Array.from(this.bots.entries()).map(async ([botKey, bot]) => {
             await bot.stop();
-            logger.debug('Bot stopped', { workspaceId: wsId });
+            logger.debug('Bot stopped', { activityId: botKey });
         }));
         this.bots.clear();
+        this.workspaceBots.clear();
     }
     getStatus() {
-        return Array.from(this.bots.entries()).map(([wsId, bot]) => ({
-            workspaceId: wsId,
+        return Array.from(this.bots.entries()).map(([botKey, bot]) => ({
+            activityId: botKey,
+            workspaceId: bot.workspaceId || botKey,
             connected: bot.connected,
-            displayName: wsId,
+            displayName: bot.workspaceId || botKey,
         }));
     }
     getBotCount() {
@@ -85,48 +121,60 @@ class BotManager {
     }
     /**
      * Handle hot reload from webhook updates.
-     * Only processes orchestrator bots. Workspace-isolated — only touches
-     * the bot for the specified workspaceId, never affects other workspaces.
+     * Supports all bot types. Routes by activityId so multiple bots
+     * can run in the same workspace independently.
      */
     async handleBotUpdate(workspaceId, bot, action) {
-        if (bot.botType !== 'orchestrator') {
-            logger.debug('Ignoring non-orchestrator bot update', { workspaceId, botType: bot.botType });
+        const botKey = bot.activityId;
+        if (!botKey) {
+            logger.warn('Bot update missing activityId, skipping', { workspaceId });
             return;
         }
-        const running = this.bots.has(workspaceId);
+        const running = this.bots.has(botKey);
         if (action === 'remove' || !bot.enabled) {
             if (running) {
-                logger.info('Stopping bot (disabled via webhook)', { workspaceId });
-                await this.stopBot(workspaceId);
+                logger.info('Stopping bot (disabled via webhook)', { activityId: botKey, workspaceId });
+                await this.stopBot(botKey, workspaceId);
             }
             return;
         }
         // Validate credentials before proceeding
         if (!/.+@.+\..+/.test(bot.email) || !bot.password || bot.password.length < 6) {
-            logger.warn('Invalid bot credentials, skipping', { workspaceId });
+            logger.warn('Invalid bot credentials, skipping', { activityId: botKey, workspaceId });
             return;
         }
         // action is 'add' or 'update' with enabled=true
         if (running) {
-            // Restart — credentials or config may have changed
-            logger.info('Restarting bot (updated via webhook)', { workspaceId });
-            await this.stopBot(workspaceId);
+            const runningBot = this.bots.get(botKey);
+            // If only the system prompt changed, update it live — no restart needed
+            const credentialsChanged = runningBot.email !== bot.email || runningBot.password !== bot.password;
+            if (!credentialsChanged) {
+                logger.info('Updating system prompt live (no restart needed)', { activityId: botKey, workspaceId });
+                runningBot.updateSystemPrompt(bot.systemPrompt);
+                return;
+            }
+            // Credentials changed — full restart required
+            logger.info('Restarting bot (credentials updated via webhook)', { activityId: botKey, workspaceId });
+            await this.stopBot(botKey, workspaceId);
         }
         const config = {
+            activityId: botKey,
             workspaceId,
             workspaceName: workspaceId,
             email: bot.email,
             password: bot.password,
             displayName: bot.displayName,
+            systemPrompt: bot.systemPrompt,
             enabled: true,
             apiHost: this.apiHost,
         };
         try {
             await this.startBot(config);
-            logger.info('Bot started via webhook', { workspaceId, displayName: bot.displayName });
+            logger.info('Bot started via webhook', { activityId: botKey, workspaceId, displayName: bot.displayName });
         }
         catch (error) {
             logger.error('Failed to start bot via webhook', {
+                activityId: botKey,
                 workspaceId,
                 error: error instanceof Error ? error.message : String(error),
             });

package/dist/bot/bot.d.ts

@@ -18,6 +18,7 @@ export declare class Bot {
     private workspaceOverview;
     private userId;
     private _workspaceId;
+    private _systemPrompt;
     private conversationManager;
     private messageClassifier;
     private messageFormatter;
@@ -45,6 +46,7 @@ export declare class Bot {
     private adminUserIds;
     private ownerUserIds;
     private config;
+    private botManager;
     constructor(config: {
         email: string;
         password: string;
@@ -53,9 +55,20 @@ export declare class Bot {
         model?: string;
         toolRegistry: ToolRegistry;
         workspaceId?: string;
+        systemPrompt?: string;
+        botManager?: any;
     });
+    get email(): string;
+    get password(): string;
+    /**
+     * Hot-update the system prompt without restarting the bot.
+     * Takes effect on the next message processed.
+     */
+    updateSystemPrompt(prompt: string | undefined): void;
     get connected(): boolean;
     get workspaceId(): string | undefined;
+    /** Exposed for BotManager cross-bot awareness */
+    get botUserId(): string;
     start(): Promise<void>;
     stop(): Promise<void>;
     private handleSignal;