@hailer/mcp 1.1.10 → 1.1.12

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/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;

package/dist/bot/bot.js

@@ -72,6 +72,19 @@ const UNGATED_TOOLS = new Set([
     'fetch_discussion_messages',
     'get_activity_from_discussion',
 ]);
+/** Minimal tool set for SIMPLE-routed messages (greetings, quick lookups). */
+const SIMPLE_TOOLS = new Set([
+    'list_workflows_minimal',
+    'list_activities',
+    'show_activity_by_id',
+    'count_activities',
+    'search_workspace_users',
+    'get_workspace_balance',
+    'list_my_discussions',
+    'fetch_discussion_messages',
+    'add_discussion_message',
+    'get_insight_data',
+]);
 const MODEL_HAIKU = 'claude-haiku-4-5-20251001';
 const MODEL_SONNET = 'claude-sonnet-4-5-20250929';
 const MAX_TOOL_ITERATIONS = 10;
@@ -91,6 +104,8 @@ class Bot {
     workspaceOverview = '';
     userId = '';
     _workspaceId;
+    // Live-updatable system prompt (separate from config so it can be hot-swapped)
+    _systemPrompt;
     // Services
     conversationManager = null;
     messageClassifier = null;
@@ -121,23 +136,44 @@ class Bot {
     ownerUserIds = new Set();
     // Config
     config;
+    botManager; // BotManager ref for cross-bot awareness
     constructor(config) {
         this.config = {
             ...config,
             model: config.model || 'claude-haiku-4-5-20251001',
         };
+        this.botManager = config.botManager || null;
+        this._systemPrompt = config.systemPrompt;
         this.logger = (0, logger_1.createLogger)({ component: 'Bot' });
         this.clientManager = new hailer_clients_1.HailerClientManager(config.apiHost, config.email, config.password);
         this.toolExecutor = new tool_executor_1.ToolExecutor(config.toolRegistry);
     }
+    get email() { return this.config.email; }
+    get password() { return this.config.password; }
+    /**
+     * Hot-update the system prompt without restarting the bot.
+     * Takes effect on the next message processed.
+     */
+    updateSystemPrompt(prompt) {
+        this._systemPrompt = prompt;
+        this.logger.info('System prompt updated live', { hasPrompt: !!prompt });
+    }
     get connected() {
         return this._connected;
     }
     get workspaceId() {
         return this._workspaceId;
     }
+    /** Exposed for BotManager cross-bot awareness */
+    get botUserId() {
+        return this.userId;
+    }
     // ===== LIFECYCLE =====
     async start() {
+        if (this._connected) {
+            this.logger.warn('Bot.start() called while already connected, ignoring');
+            return;
+        }
         this.logger.debug('Starting bot', { email: this.config.email });
         // 1. Connect to Hailer
         this.client = await this.clientManager.connect();
@@ -271,10 +307,16 @@ class Bot {
             return;
         try {
             const rawMsgId = signal.data.msg_id;
-            if (rawMsgId) {
-                if (this.processedMessageIds.has(rawMsgId))
+            const discussionId = signal.data.discussion;
+            const dedupKey = rawMsgId || (discussionId ? `${discussionId}:${signal.data.uid}:${signal.data.created}` : null);
+            if (dedupKey) {
+                if (this.processedMessageIds.has(dedupKey))
                     return;
-                this.processedMessageIds.add(rawMsgId);
+                this.processedMessageIds.add(dedupKey);
+            }
+            else {
+                this.logger.warn('messenger.new signal has no dedup key, skipping');
+                return;
             }
             const message = await this.messageClassifier.extractIncomingMessage(signal);
             if (!message) {
@@ -282,9 +324,14 @@ class Bot {
                     this.processedMessageIds.delete(rawMsgId);
                 return;
             }
-            // Self-message guard: prevent bot feedback loops
+            // Self-message guard: prevent bot feedback loops (checks ALL bots in this workspace)
             if (message.senderId === this.userId)
                 return;
+            if (this.botManager && this._workspaceId) {
+                const botUserIds = this.botManager.getBotUserIdsForWorkspace(this._workspaceId);
+                if (botUserIds.has(message.senderId))
+                    return;
+            }
             // Rate limiting
             const now = Date.now();
             const cutoff = now - RATE_LIMIT_WINDOW;
@@ -598,7 +645,7 @@ Reply with exactly one word: SIMPLE or COMPLEX`,
     async runLlmLoop(message, route, signal) {
         const conversation = this.conversationManager.getConversation(message.discussionId);
         const systemPrompt = this.buildSystemPrompt();
-        const tools = this.getAnthropicTools();
+        const tools = this.getAnthropicTools(route.classification);
         const processingStartTime = Date.now();
         for (let i = 0; i < MAX_TOOL_ITERATIONS; i++) {
             const cachedConversation = this.conversationManager.prepareForCaching(conversation);
@@ -987,41 +1034,69 @@ Reply with exactly one word: SIMPLE or COMPLEX`,
     buildSystemPrompt() {
         const wsName = this.init?.network?.name || 'Workspace';
         const botName = this.getBotDisplayName();
-        return `You are a workspace assistant for "${wsName}" on Hailer.
-
-<bot-identity>
+        const identity = `<bot-identity>
 Your user ID: ${this.userId}
 Your display name: ${botName}
-</bot-identity>
+Workspace: ${wsName}
+</bot-identity>`;
+        // Platform rules — always applied regardless of custom prompt.
+        // These are operational requirements that keep the bot functional.
+        const platformRules = `<platform-rules>
+- Use tools to answer questions — don't guess or make up data.
+- When a tool call fails, tell the user what failed and why. Never silently try alternatives.
+- For bulk operations, batch into groups of 25-50 per tool call.
+- NEVER output raw URLs like https://app.hailer.com/...
 
-<rules>
+HAILERTAG LINKING (mandatory):
+- When referencing activities, discussions, or users, ALWAYS use: [hailerTag|Display Name](objectId)
+- Examples:
+    [hailerTag|AC Milan deal](691ffe654217e9e8434e578a)
+    [hailerTag|John Smith](691ffe654217e9e8434e5123)
+- Tool responses include both names and IDs — use them directly in this format.
+- NEVER use hailerTag for workflows, phases, teams, or groups — these don't support linking. Just use their plain text names.
+- NEVER output bare 24-character hex IDs to the user.
+</platform-rules>`;
+        const wsContext = `<workspace-context>
+${this.workspaceOverview}
+</workspace-context>`;
+        const customPrompt = this._systemPrompt?.trim();
+        if (customPrompt) {
+            // Custom prompt = the bot's mission brief. It defines personality, scope, and behavior.
+            // Platform rules and identity are always appended — they keep the bot functional.
+            const body = customPrompt
+                .replace(/\{wsName\}/g, wsName)
+                .replace(/\{userId\}/g, this.userId)
+                .replace(/\{botName\}/g, botName);
+            return `${body}\n\n${platformRules}\n\n${identity}\n\n${wsContext}`;
+        }
+        // Default prompt — general-purpose workspace assistant with behavioral defaults.
+        const defaultBehavior = `<behavior>
 - Be concise. Short answers, no filler.
 - Never list your capabilities unprompted. If asked what you can do, give a 1-2 sentence summary based on the workspace context below, not a feature dump.
 - Never use emojis unless the user does first.
-- Use tools to answer questions - don't guess or make up data.
-- When a task will require multiple steps (investigating errors, fixing data, bulk lookups), briefly tell the user what you're specifically about to do before starting. Be concrete: "I'll check each insight's SQL and fix any broken column references." NEVER use vague filler like "Let me look into that" — always name the actual action.
+- When a task will require multiple steps, briefly tell the user what you're about to do. Be concrete — never use vague filler like "Let me look into that".
 - When showing data, use clean formatting (tables, bullet points). Don't over-explain.
 - If a request is ambiguous, ask a clarifying question instead of guessing.
-- Always reference actual workspace data (workflow names, field values) - never speak in generic terms.
-- For bulk operations (creating/updating many items), batch into groups of 25-50 per tool call. Never try to create more than 50 items in a single tool call.
-- When a tool call fails, ALWAYS tell the user what failed and why. Never silently try alternatives. If an insight has a SQL error, tell the user the insight is broken, explain what's wrong (e.g. missing column), and offer to fix it using update_insight. Fix the root cause, don't work around it.
-- NEVER output raw URLs like https://app.hailer.com/...
-- When referencing activities, discussions, or users, use hailerTag format: [hailerTag|Display Name](objectId)
-  Examples: [hailerTag|AC Milan](691ffe654217e9e8434e578a) or [hailerTag|John Smith](691ffe654217e9e8434e5123)
-  You always have the name and ID from tool responses - use them directly in this format.
-</rules>
+- Always reference actual workspace data (workflow names, field values) — never speak in generic terms.
+</behavior>`;
+        return `You are a workspace assistant for "${wsName}" on Hailer.
 
-<workspace-context>
-${this.workspaceOverview}
-</workspace-context>`;
+${identity}
+
+${platformRules}
+
+${defaultBehavior}
+
+${wsContext}`;
     }
     // ===== TOOLS =====
-    getAnthropicTools() {
+    getAnthropicTools(classification) {
+        const allowedTools = classification === 'SIMPLE' ? SIMPLE_TOOLS : BOT_TOOLS;
         const defs = this.toolExecutor.getToolDefinitions({
             allowedGroups: [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE, tool_registry_1.ToolGroup.PLAYGROUND, tool_registry_1.ToolGroup.BOT_INTERNAL],
         });
         return defs
-            .filter(d => BOT_TOOLS.has(d.name))
+            .filter(d => allowedTools.has(d.name))
             .map(d => ({
             name: d.name,
             description: d.description,

package/dist/mcp/hailer-clients.js

@@ -204,7 +204,10 @@ class HailerClientManager {
         if (!this.signalHandlers.has(eventType)) {
             this.signalHandlers.set(eventType, []);
         }
-        this.signalHandlers.get(eventType).push(handler);
+        const handlers = this.signalHandlers.get(eventType);
+        if (!handlers.includes(handler)) {
+            handlers.push(handler);
+        }
     }
     // Remove a signal handler
     offSignal(eventType, handler) {

package/dist/mcp/signal-handler.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignalHandler = void 0;
 const logger_1 = require("../lib/logger");
+const webhooks_1 = require("../bot-config/webhooks");
 // Optional: bot-config only available in bot server mode, not MCP terminal
 let reloadConfigFromHailer = null;
 let setActiveWorkspace = null;
@@ -169,18 +170,15 @@ class SignalHandler {
             prevPhase: data.prevPhase || data.meta?.prevPhase
         });
         // Handle Agent Directory phase changes for bot enable/disable
-        // DISABLED: Now using webhook instead of socket signals for Agent Directory updates
-        // The webhook handler (src/mcp/webhook-handler.ts) handles bot config updates
-        // Keeping this code for potential fallback if webhook is unavailable
-        // if (processId && phase && activityIdRaw) {
-        //   const activityIds = Array.isArray(activityIdRaw)
-        //     ? activityIdRaw
-        //     : [activityIdRaw];
-        //
-        //   handleActivityPhaseChange(processId, activityIds, phase).catch(err => {
-        //     logger.error('Failed to handle activity phase change', err);
-        //   });
-        // }
+        // Socket signals as primary path, webhook as backup
+        if (processId && phase && activityIdRaw) {
+            const activityIds = Array.isArray(activityIdRaw)
+                ? activityIdRaw
+                : [activityIdRaw];
+            (0, webhooks_1.handleActivityPhaseChange)(processId, activityIds, phase).catch(err => {
+                logger.error('Failed to handle activity phase change', err);
+            });
+        }
     }
     handleActivityCreated(signal) {
         const data = signal.data;

package/dist/mcp/webhook-handler.d.ts

@@ -49,6 +49,7 @@ interface BotEntry {
     botType: string;
     enabled: boolean;
     displayName?: string;
+    systemPrompt?: string;
 }
 interface WorkspaceConfig {
     workspaceId: string;
@@ -59,6 +60,7 @@ interface WorkspaceConfig {
         email: string;
         password: string;
         displayName?: string;
+        systemPrompt?: string;
     };
     specialists: BotEntry[];
     lastSynced: string;

package/dist/mcp/webhook-handler.js

@@ -221,6 +221,7 @@ function handleBotConfigWebhook(payload) {
     const botType = getFieldValue(payload.fields, 'botType');
     const userId = getFieldValue(payload.fields, 'hailerProfile');
     const schemaConfigStr = getFieldValue(payload.fields, 'schemaConfig');
+    const systemPrompt = getFieldValue(payload.fields, 'systemPrompt') || undefined;
     // Validate required fields
     if (!email || !password) {
         logger.warn('Webhook missing credentials', {
@@ -262,6 +263,7 @@ function handleBotConfigWebhook(payload) {
         botType: botType || 'unknown',
         enabled,
         displayName: payload.name, // Activity name from Agent Directory
+        systemPrompt,
     };
     let action;
     // Handle orchestrator
@@ -273,6 +275,7 @@ function handleBotConfigWebhook(payload) {
                 email,
                 password,
                 displayName: payload.name,
+                systemPrompt,
             };
             action = 'update';
             logger.info('Updated orchestrator', { workspaceId, email: (0, config_1.maskEmail)(email), displayName: payload.name });

package/inbox/2026-03-04-bot-config-patterns.md

@@ -0,0 +1,24 @@
+# Bot Config Field Wiring Patterns
+
+**Date:** 2026-03-04
+**Context:** Adding systemPrompt field to Agent Directory pipeline
+
+## Key Gotchas
+
+### seed-config.ts is an independent copy
+`src/commands/seed-config.ts` has its own field extraction logic completely separate from `src/bot-config/context.ts`. When adding a new Agent Directory field, you MUST update BOTH files — they don't share code.
+
+### Two separate bot-config readers
+- `src/bot-config/loader.ts` — BotContext system, used by webhook/signal path
+- `src/bot/bot-config.ts` — simple flat reader, used by BotManager on startup
+
+Both read from `.bot-config/*.json` but in different ways. Both need updating when adding new fields.
+
+### webhook-handler.ts has its own local types
+`BotEntry` and `WorkspaceConfig` are defined locally inside `webhook-handler.ts`, not imported from anywhere. Must update them independently when adding fields.
+
+### Webhook fires on phase changes only (with delay)
+Field edits (e.g. systemPrompt) trigger the webhook but with a delay — Hailer batches/debounces. Phase changes are more immediate. For truly instant field-change detection, subscribe to the `activities.updated` socket signal inside the Bot (requires knowing the bot's own `activityId`).
+
+### Hot-swap system prompts without restart
+Pattern for live-updatable config in Bot: store as a separate instance field (`_systemPrompt`) distinct from `this.config`. Expose `updateSystemPrompt(prompt)` public method. BotManager can call it without restarting the bot — only restart when credentials actually change.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hailer/mcp",
-  "version": "1.1.10",
+  "version": "1.1.12",
   "config": {
     "docker": {
       "registry": "registry.gitlab.com/hailer-repos/hailer-mcp"
@@ -25,7 +25,8 @@
     "release:patch": "npm version patch -m 'chore: release v%s' && git push && git push --tags && npm run build && npm publish --access public",
     "release:minor": "npm version minor -m 'chore: release v%s' && git push && git push --tags && npm run build && npm publish --access public",
     "release:major": "npm version major -m 'chore: release v%s' && git push && git push --tags && npm run build && npm publish --access public",
-    "seed-config": "tsx src/commands/seed-config.ts"
+    "seed-config": "tsx src/commands/seed-config.ts",
+    "postinstall": "node scripts/postinstall.cjs"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.54.0",

package/scripts/postinstall.cjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+/**
+ * postinstall: Copies .claude/ (agents, skills, hooks) to the project root.
+ * Runs automatically after `npm install @hailer/mcp`.
+ * Skips when installing in the hailer-mcp repo itself (development).
+ */
+const fs = require('fs');
+const path = require('path');
+
+// Find the project root by walking up from node_modules/@hailer/mcp/
+function findProjectRoot() {
+  let dir = __dirname;
+  // Walk up until we find a package.json that isn't ours
+  for (let i = 0; i < 10; i++) {
+    dir = path.dirname(dir);
+    const pkgPath = path.join(dir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        // Skip if this is our own package.json
+        if (pkg.name === '@hailer/mcp') continue;
+        return dir;
+      } catch { continue; }
+    }
+  }
+  return null;
+}
+
+function copyDir(src, dest) {
+  if (!fs.existsSync(src)) return;
+  fs.mkdirSync(dest, { recursive: true });
+
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      // Don't overwrite user's local settings
+      if (entry.name === 'settings.local.json' && fs.existsSync(destPath)) continue;
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+const projectRoot = findProjectRoot();
+
+// Skip if we can't find a project root or if running in dev (our own repo)
+if (!projectRoot) {
+  console.log('@hailer/mcp: skipping agent install (no project root found)');
+  process.exit(0);
+}
+
+const src = path.join(__dirname, '..', '.claude');
+const dest = path.join(projectRoot, '.claude');
+
+if (!fs.existsSync(src)) {
+  console.log('@hailer/mcp: no .claude/ directory in package, skipping');
+  process.exit(0);
+}
+
+copyDir(src, dest);
+console.log(`@hailer/mcp: agents installed to ${dest}`);