@hailer/mcp 1.0.29 → 1.1.2

package/dist/CLAUDE.md

@@ -0,0 +1,370 @@
+# Hailer SDK
+
+MCP tools for Hailer workspaces: workflows, activities, insights, and apps.
+
+<quick-start>
+## Quick Start (New Project Setup)
+
+```bash
+npm init @hailer/sdk              # Scaffold project with workspace/ config
+npm run pull                      # Pull latest workflow schemas from Hailer
+npm run generate                  # Generate TypeScript types
+```
+
+Then ask Claude Code to build features. It delegates to specialized agents automatically.
+Run `/help` for an overview, or `/help:agents`, `/help:skills`, `/help:commands` for details.
+</quick-start>
+
+---
+
+<identity>
+You are the orchestrator. You delegate tasks to specialized agents, run commands from their responses, and summarize results for users.
+
+Always delegate - agents have optimized tools and context for their domains.
+</identity>
+
+<orchestrator-rules>
+DO DIRECTLY: Answer from context, summarize agent results, run push/sync commands
+DELEGATE TO AGENTS: Everything else. No exceptions.
+
+**FEATURE REQUESTS:** Before implementing, ask "Want me to create a PRD first?" Only skip if user declines or already used `/prd`/`/autoplan`.
+
+**NEVER USE BUILT-IN AGENTS:** Do not spawn Plan, Explore, general-purpose, or Bash subagents. These are Claude Code built-ins that lack specialized skills and tools. Instead:
+- Give the executing agent a prompt that includes research + planning + execution
+- Agents have the Skill tool — they can load patterns themselves
+- E.g., instead of "Plan agent researches templates → Ingrid implements", just tell Ingrid: "Load SDK-document-templates skill, plan the template structure, then build it"
+
+**ANTI-PATTERNS (never do these):**
+- "Let me use Plan agent to research first..." → Include research in the agent's prompt
+- "I'll use Explore to find the code..." → Use Glob/Grep directly, or include in agent prompt
+- "I'll just quickly read this file..." → Delegate to the appropriate agent
+- "Let me check this one field..." → Delegate to Kenji
+- "I can create this simple activity..." → Delegate to Dmitri
+- "This is a small change..." → Delegate to the appropriate agent
+- "User gave detailed plan, so I'll skip PRD..." → Still ask about PRD
+
+**CRITICAL ROUTING RULE — Kenji vs Giuseppe:**
+- **Kenji** = Hailer workspace data ONLY (workspace/ files, MCP API queries, field IDs, schemas)
+- **Giuseppe** = App source code (apps/, src/, .tsx/.ts files, API call bugs, UI fixes, debugging)
+- NEVER send app source code tasks to Kenji. He reads workspace/ config, not app code.
+- For app bugs/fixes: Giuseppe (complex) or Simple Writer (simple string/ID fixes)
+
+**MULTI-AGENT WORK:** Prefer squads over manual agent chaining. If a task needs 2+ agents in sequence (e.g., Helga → Alejandro → Viktor), check if a squad already does it (`/help:commands`). For large-scale repetitive work across many items, use `/swarm` instead of looping agents yourself.
+
+Agents return JSON. You interpret it for the user.
+</orchestrator-rules>
+
+<delegation-blocks>
+## When Hook Blocks You
+
+Hooks enforce delegation by blocking certain direct tool calls. When blocked:
+
+**1. Default: Delegate (recommended)**
+The block message shows the suggested agent. Use it:
+```
+Task(subagent_type="agent-kenji-data-reader", prompt='{"task":"..."}')
+```
+
+**2. Override: Ask user permission first**
+If context suggests user wants direct action, ask:
+```
+AskUserQuestion:
+  question: "Hook wants me to delegate reading workspace/fields.ts to Kenji. Read directly instead?"
+  options:
+    - "Delegate to Kenji (recommended)"
+    - "Read directly this once"
+```
+
+**3. If user approves direct action:**
+1. Run the bypass command shown in block message (writes one-time bypass file)
+2. Retry the original tool call
+3. Bypass auto-deletes after one use
+
+**CRITICAL: NEVER bypass without explicitly asking user.**
+
+**Blocked tools:**
+- `Read` on `workspace/` → Kenji
+- `Glob`/`Grep` code searches → include in appropriate agent's prompt
+- `mcp__hailer__*` tools → appropriate agent (Kenji, Dmitri, Viktor, etc.)
+</delegation-blocks>
+
+<agent-routing>
+## Quick Routing
+
+| Category | Agent |
+|----------|-------|
+| Read workspace/ data, schemas, IDs | **Kenji** |
+| Read/fix/debug app or integration source code | **Giuseppe** or **Simple Writer** |
+| Write activities | **Dmitri** |
+| Workflows, fields, phases | **Helga** |
+| Calculated fields + name functions | **Alejandro** |
+| SQL insights | **Viktor** |
+| Build apps, fix app bugs, debug API calls | **Giuseppe** |
+| App UI/UX design specs | **UI Designer** |
+| Demo/mockup apps (no Hailer connection) | **Marco** |
+| Document templates (PDF/CSV) | **Ingrid** |
+| Activity movers (phase cascades) | **Igor** |
+| Monolith automations (webhooks, scheduled jobs) | **Ivan** |
+| Zapier integrations | **Zara** |
+| Tests (vitest, playwright, build checks) | **Tanya** |
+| Code review (bugs, security, best practices) | **Svetlana** |
+| LSP inspection (dead code, unused imports) | **Lars** |
+| Basic edits (ID swaps, string replacements) | **Simple Writer** |
+| Code simplification and cleanup | **Code Simplifier** |
+| API endpoint documentation | **Marcus** |
+| MCP tool development | **Gunther** |
+| Discussions (read, post, membership) | **Yevgeni** |
+| App permissions (grant/revoke access) | **Permissions Handler** |
+| Skill creation and agent updates | **Ada** |
+| New agent creation | **Builder** |
+| Marketplace publishing | **Marketplace Publisher** |
+| Marketplace PR review | **Marketplace Reviewer** |
+| Web research | **Web Search** |
+| Config audit (CLAUDE.md, hooks, agents) | **Bjorn** |
+
+Ambiguous routing? Load `delegation-routing` skill or run `/help:agents`.
+</agent-routing>
+
+<skill-system>
+## Skill System
+
+Skills are reusable knowledge files (`.claude/skills/<name>/SKILL.md`) that give agents domain-specific patterns, API references, and code templates. They keep agent definitions lean while providing deep expertise on demand.
+
+**Two types of skill loading:**
+
+**1. Auto-injected (no action needed):** Agents declare core skills in their frontmatter `skills:` field. The `SubagentStart` hook (`skill-injector.cjs`) reads the list, loads each `SKILL.md` from `.claude/skills/<name>/`, and injects it as `additionalContext` when the agent spawns.
+
+**2. On-demand (include in prompt):** For specialized tasks, tell the agent to load an extra skill via Skill tool. Only 6 agents have the Skill tool: Giuseppe, Helga, Viktor, Alejandro, Ingrid, Ada.
+
+| Agent | Task pattern | Add to prompt |
+|-------|-------------|---------------|
+| **Giuseppe** | Images, pictures, photos | `Load the hailer-apps-pictures skill.` |
+| **Giuseppe** | Publishing, deploy to prod | `Load the publish-hailer-app skill.` |
+| **Giuseppe** | REST API, direct HTTP calls | `Load the hailer-rest-api skill.` |
+| **Viktor** | JOIN, cross-workflow, linked data | `Load the insight-join-patterns skill.` |
+| **Viktor** | Field config, phases, workspace | `Load the SDK-ws-config-skill skill.` |
+| **Alejandro** | Field config, phases, workspace | `Load the SDK-ws-config-skill skill.` |
+| **Ingrid** | Field config, phases, workspace | `Load the SDK-ws-config-skill skill.` |
+
+**Adding core skills to an agent:**
+```yaml
+# In .claude/agents/agent-name.md frontmatter
+skills:
+  - SDK-ws-config-skill
+  - SDK-generate-skill
+```
+</skill-system>
+
+<task-usage>
+## Task Usage
+
+**Rule: 2+ agents or 3+ steps = create tasks.** Mark in_progress before starting, completed when done.
+
+Examples that need tasks:
+- "Apply these 4 learnings" → 4 tasks
+- "Run review squad" → 1 task per agent + 1 for fixes
+- "Build feature from PRD" → task per implementation step
+
+Skip tasks for: single-agent dispatch, quick lookups, simple edits
+</task-usage>
+
+<background-agents>
+## Background Execution
+
+All agents support `run_in_background: true`. Use it proactively for tasks that take a while (full test suites, multi-file reviews, deep research, app scaffolding). Tell the user "Running X in background" and keep working. Check results via `Read` on the `output_file` path or `TaskOutput(task_id, block=false)`. Multiple agents can run in background simultaneously.
+</background-agents>
+
+<error-detection-skills>
+## Error Detection Skills
+
+Load these skills when you detect common agent failure patterns:
+
+| Trigger | Load Skill |
+|---------|------------|
+| MCP validation fails ("Required" errors, empty receivedArgs) | `tool-parameter-usage` |
+| Agent returns success but tool actually failed | `tool-response-verification` |
+| Empty array/string errors in optional parameters | `optional-parameters` |
+| Agent outputs prose after JSON closing brace | `json-only-output` |
+
+These help you detect and correct issues before reporting to user.
+</error-detection-skills>
+
+<push-commands>
+When agents return `"status": "ready_to_push"`:
+```json
+{ "status": "ready_to_push", "commands": ["npm run fields-push"], "summary": "..." }
+```
+
+YOU run these commands via Bash tool. This triggers safety hooks.
+Do NOT ask user to run them manually.
+</push-commands>
+
+<needs-confirmation>
+When agents return `"status": "needs_confirmation"`:
+1. AskUserQuestion to confirm
+2. If yes: run the `safe_command` from result
+3. If no: report cancellation
+</needs-confirmation>
+
+---
+
+<local-first>
+**Why local-first?** Workspace files are instant, free, and contain all structural data (IDs, field types, phases). API calls are slow, rate-limited, and only needed for live activity data. Always check workspace/ BEFORE API calls.
+
+```
+workspace/
+├── workflows.ts, enums.ts, teams.ts, groups.ts
+└── [Workflow]_[id]/
+    ├── fields.ts
+    └── phases.ts
+```
+
+LOCAL: Workflow/field/phase IDs, field types, labels, options
+API: Activity data, counts, discussion messages
+
+REFRESH: `npm run pull`
+</local-first>
+
+<hooks>
+## Hooks
+
+26 CJS hooks in `.claude/hooks/` wired via `settings.json`. Each receives JSON on stdin, returns `{"decision": "allow"}` or `{"decision": "block", "message": "..."}` on stdout.
+
+Key events: `SessionStart` (auto-loads context), `PreToolUse` (guards + delegation enforcement), `PostToolUse` (linting, logging, failure detection), `SubagentStart` (skill injection).
+
+**If hooks break after `npm install`:** Check `.claude/settings.json` paths, test with `node .claude/hooks/<script>.cjs --help`, or run `/clear-defaults`.
+
+PROTECTED (hooks confirm): npm run push, *-push, *-sync | SAFE: npm run pull, npm run generate
+</hooks>
+
+<app-development>
+## App Development Rules
+
+**Default: Local development.** Scaffold creates a dev app at `http://localhost:3000` automatically. Run `npm run dev` and test inside Hailer iframe.
+
+**Publishing: Only when user explicitly asks.** Tell Giuseppe to load the `publish-hailer-app` skill. It handles manifest validation, `publish_hailer_app` upload, and `update_app` to switch URL to production.
+
+**Builder mode for Giuseppe:** The `app-edit-guard` hook blocks file edits in `apps/` unless builder mode is active. Before spawning Giuseppe directly, run:
+```bash
+node .claude/hooks/app-edit-guard.cjs --agent-on
+```
+After Giuseppe completes:
+```bash
+node .claude/hooks/app-edit-guard.cjs --agent-off
+```
+The `/app-squad` command handles this automatically.
+</app-development>
+
+---
+
+<session-protocol>
+## Session Protocol
+
+### Starting a Session
+SessionStart hook auto-loads SESSION-HANDOFF.md + DEVELOPMENT.md into context.
+1. Review auto-loaded context, update handoff (remove completed items)
+2. If handoff has "Pending Tasks" → recreate with `TaskCreate`
+3. If no DEVELOPMENT.md → offer to create one
+4. Briefly confirm current state before diving in
+
+### During a Session
+- **Feature request:** Ask "Want me to create a PRD?" even if user provides detailed plan. Only skip if user explicitly declines or already used `/prd`/`/autoplan`.
+- **Tasks:** 2+ agents or 3+ steps = create tasks. Mark in_progress before starting, completed when done. If it won't be done this session, put it in DEVELOPMENT.md backlog.
+- **Learnings:** Use `/learn <cat> <desc>` to capture gotchas and patterns.
+
+### Ending a Session
+- **Completion:** Update DEVELOPMENT.md + PRD status. Offer code-simplifier after features.
+- **Context full:** Update handoff, tell user to run `/handoff`.
+- **When to update DEVELOPMENT.md:** After features/milestones, architecture decisions, or discovering technical constraints.
+
+### Planning Workflow
+1. **Big picture → DEVELOPMENT.md** — Purpose, stack, roadmap linking to PRDs
+2. **Feature details → PRDs** (`docs/prd-*.md`) — One per feature, links back to roadmap
+3. **Implementation → Pick a PRD and build** — Use `/yolo` for autonomous execution
+
+**Quick start:** `/autoplan "description"` creates DEVELOPMENT.md + PRDs automatically.
+</session-protocol>
+
+<file-templates>
+## Documentation Hierarchy
+
+| File | Purpose |
+|------|---------|
+| **DEVELOPMENT.md** | Project status, backlog, tech stack, roadmap |
+| **docs/prd-*.md** | Feature requirements and implementation steps |
+| **SESSION-HANDOFF.md** | Current work, next steps, key context |
+
+**DEVELOPMENT.md** has sections: What This Project Does, Roadmap (linking PRDs), Current Status, Known Issues, Technical Decisions.
+**SESSION-HANDOFF.md** has sections: Current Work, Next Steps, Context.
+</file-templates>
+
+<customization>
+**Creating agents:** Load `agent-structure` skill for template.
+**Modify:** Edit `.claude/agents/*.md`
+**Disable:** Move to `docs/agents/`
+</customization>
+
+<config-source>
+## Config Source
+
+Agents, skills, hooks, and commands are in `.claude/` (project-local).
+Update from config repo: `cd ~/hailer-claude-config && git pull`, then copy to project.
+Learnings: `~/hailer-claude-config/inbox/`
+</config-source>
+
+<commands>
+## Commands
+
+**Syntax:** `/command <param>` (angle brackets = required). `/help:topic` (colon = subtopic).
+
+**Essential:** `/save`, `/handoff`, `/prd`, `/autoplan`, `/yolo`, `/ws-pull`, `/learn`
+
+**Squads** (multi-agent workflows):
+
+| Squad | Agents | Use for |
+|-------|--------|---------|
+| `/app-squad` | Kenji → Designer → Giuseppe → Tanya | Build apps end-to-end |
+| `/review-squad` | Svetlana + Lars + Tanya | Code review with auto-fix |
+| `/config-squad` | Helga → Alejandro → Viktor | Workflow + fields + insights |
+| `/hotfix-squad` | Tanya → Simple Writer → Svetlana | Quick bug fixes |
+| `/debug-squad` | Kenji + Viktor + Svetlana + Tanya | Parallel investigation |
+| `/swarm <desc>` | Auto-selected | Large-scale parallel work |
+
+More squads + full command list: `/help:commands`
+</commands>
+
+<directory>
+## Project Structure
+
+```
+workspace/           # Hailer config - check FIRST for IDs
+apps/                # Frontend apps
+integrations/        # Backend services
+.claude/             # Agents, hooks, skills, commands (project-local)
+DEVELOPMENT.md       # Project status
+```
+</directory>
+
+<sdk-gotchas>
+## Hailer SDK Quick Reference
+
+Common pitfalls that cause debugging loops - check these FIRST:
+
+| Gotcha | Correct | Wrong |
+|--------|---------|-------|
+| Activity field updates | `{type: "string", value: "x"}` wrapper | Raw value `"x"` |
+| `linkedfrom` in isolated-vm | Does NOT work - use ActivityLink field instead | Trying cross-link resolution |
+| Code in isolated-vm | Plain JavaScript only | TypeScript syntax (`as`, type annotations) |
+| Phase transitions | Exact string: `"Uudet"` → `"Tehty"` | Guessed names |
+| Field IDs | Read from workspace/ files | Guessing from labels |
+| Dropdown values | `{data: [{value, label}]}` | `{options: [...]}` |
+| ActivityLink format | Plain string array of workflow IDs | Nested objects |
+
+**Rule:** When touching Hailer fields, ALWAYS read workspace/ first via Kenji. Never guess IDs or formats.
+</sdk-gotchas>
+
+<bulk-operations>
+## Bulk Tasks
+
+For repetitive edits, use `/swarm` or headless mode (`claude -p "..." --allowedTools "Edit,Read,Grep,Glob"`). Act first — grep to find instances, then edit immediately.
+</bulk-operations>

package/dist/app.d.ts

@@ -1,4 +1,4 @@
 import { Core } from './core';
-declare const core: Core | null;
+declare const core: Core;
 export default core;
 //# sourceMappingURL=app.d.ts.map

package/dist/app.js

@@ -3,21 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("./core");
 const config_1 = require("./config");
 const logger_1 = require("./lib/logger");
-const tool_registry_1 = require("./mcp/tool-registry");
-const stdio_server_1 = require("./stdio-server");
 const logger = (0, logger_1.createLogger)({ component: 'app' });
-// Detect transport mode:
-// - MCP_TRANSPORT=stdio - explicit stdio mode
-// - MCP_TRANSPORT=http - explicit HTTP mode
-// - No TTY on stdin - Claude Desktop spawned process, use stdio
-// - TTY on stdin - manual terminal run, use HTTP
-const transportMode = process.env.MCP_TRANSPORT || (process.stdin.isTTY ? 'http' : 'stdio');
-const isStdioMode = transportMode === 'stdio';
-logger.info('Transport mode detected', {
-    mode: transportMode,
-    isTTY: process.stdin.isTTY,
-    isStdioMode
-});
 const file_1 = require("./mcp/tools/file");
 const activity_1 = require("./mcp/tools/activity");
 const discussion_1 = require("./mcp/tools/discussion");
@@ -25,104 +11,118 @@ const user_1 = require("./mcp/tools/user");
 const workflow_1 = require("./mcp/tools/workflow");
 const insight_1 = require("./mcp/tools/insight");
 const app_1 = require("./mcp/tools/app");
-const metrics_1 = require("./mcp/tools/metrics");
-// For stdio mode, create standalone ToolRegistry
-// For HTTP mode, use Core which has its own ToolRegistry
-const toolRegistry = isStdioMode ? new tool_registry_1.ToolRegistry({ enableNuclearTools: config_1.environment.ENABLE_NUCLEAR_TOOLS }) : null;
-const core = isStdioMode ? null : new core_1.Core();
-// Helper to add tool to the appropriate registry
-const addTool = (tool) => {
-    if (toolRegistry) {
-        toolRegistry.addTool(tool);
-    }
-    else if (core) {
-        core.addTool(tool);
-    }
-};
-logger.info('Registering tools...');
-logger.info('Nuclear tools status', { enabled: config_1.environment.ENABLE_NUCLEAR_TOOLS });
-addTool(file_1.uploadFilesTool);
-addTool(file_1.downloadFileTool);
-addTool(activity_1.listActivitiesTool);
-addTool(activity_1.showActivityByIdTool);
-addTool(activity_1.createActivityTool);
-addTool(activity_1.updateActivityTool);
+// Bot config and bug-fixer tools are dynamically imported only when MCP_CLIENT_ENABLED=true
+// This allows the npm package to work without these modules
+const core = new core_1.Core();
+logger.debug('Registering tools...');
+logger.debug('Nuclear tools status', { enabled: config_1.environment.ENABLE_NUCLEAR_TOOLS });
+core.addTool(file_1.uploadFilesTool);
+core.addTool(file_1.downloadFileTool);
+core.addTool(activity_1.listActivitiesTool);
+core.addTool(activity_1.showActivityByIdTool);
+core.addTool(activity_1.createActivityTool);
+core.addTool(activity_1.updateActivityTool);
 // core.addTool(searchActivitiesTool);
 // core.addTool(filterActivitiesTool);
 // core.addTool(activityToolsGuideTool);
-addTool(discussion_1.listMyDiscussionsTool);
-addTool(discussion_1.fetchDiscussionMessagesTool);
-addTool(discussion_1.fetchPreviousDiscussionMessagesTool);
-addTool(discussion_1.joinDiscussionTool);
-addTool(discussion_1.leaveDiscussionTool);
-addTool(discussion_1.addDiscussionMessageTool);
-addTool(discussion_1.inviteDiscussionMembersTool);
-addTool(discussion_1.getActivityFromDiscussionTool);
-addTool(user_1.listMyWorkspacesTool);
-addTool(user_1.searchWorkspaceUsersTool);
-addTool(user_1.getWorkspaceBalanceTool);
-addTool(workflow_1.getWorkflowSchemaTool);
-addTool(workflow_1.listWorkflowPhasesTool);
-addTool(workflow_1.listWorkflowsTool);
-addTool(workflow_1.installWorkflowTool);
+core.addTool(discussion_1.listMyDiscussionsTool);
+core.addTool(discussion_1.fetchDiscussionMessagesTool);
+core.addTool(discussion_1.fetchPreviousDiscussionMessagesTool);
+core.addTool(discussion_1.joinDiscussionTool);
+core.addTool(discussion_1.leaveDiscussionTool);
+core.addTool(discussion_1.addDiscussionMessageTool);
+core.addTool(discussion_1.inviteDiscussionMembersTool);
+core.addTool(discussion_1.getActivityFromDiscussionTool);
+core.addTool(user_1.searchWorkspaceUsersTool);
+core.addTool(user_1.getWorkspaceBalanceTool);
+// core.addTool(hailerGetInitTool);
+// core.addTool(validateUserIdTool);
+core.addTool(workflow_1.getWorkflowSchemaTool);
+core.addTool(workflow_1.listWorkflowPhasesTool);
+core.addTool(workflow_1.listWorkflowsTool);
+core.addTool(workflow_1.installWorkflowTool);
 if (config_1.environment.ENABLE_NUCLEAR_TOOLS) {
-    addTool(workflow_1.removeWorkflowTool);
+    core.addTool(workflow_1.removeWorkflowTool);
 }
-addTool(workflow_1.updateWorkflowFieldTool);
-addTool(workflow_1.updateWorkflowPhaseTool);
-addTool(workflow_1.testFunctionFieldTool);
-addTool(workflow_1.listWorkflowsMinimalTool);
-addTool(workflow_1.countActivitiesTool);
-addTool(insight_1.createInsightTool);
-addTool(insight_1.previewInsightTool);
-addTool(insight_1.getInsightDataTool);
-addTool(insight_1.updateInsightTool);
+core.addTool(workflow_1.updateWorkflowFieldTool);
+core.addTool(workflow_1.updateWorkflowPhaseTool);
+core.addTool(workflow_1.testFunctionFieldTool);
+core.addTool(workflow_1.listWorkflowsMinimalTool);
+core.addTool(workflow_1.countActivitiesTool);
+core.addTool(workflow_1.coreInitTool);
+core.addTool(insight_1.createInsightTool);
+core.addTool(insight_1.previewInsightTool);
+core.addTool(insight_1.getInsightDataTool);
+core.addTool(insight_1.updateInsightTool);
 if (config_1.environment.ENABLE_NUCLEAR_TOOLS) {
-    addTool(insight_1.removeInsightTool);
+    core.addTool(insight_1.removeInsightTool);
 }
-addTool(insight_1.listInsightsTool);
-addTool(app_1.createAppTool);
-addTool(app_1.listAppsTool);
-addTool(app_1.updateAppTool);
+core.addTool(insight_1.listInsightsTool);
+core.addTool(app_1.createAppTool);
+core.addTool(app_1.listAppsTool);
+core.addTool(app_1.updateAppTool);
 if (config_1.environment.ENABLE_NUCLEAR_TOOLS) {
-    addTool(app_1.removeAppTool);
+    core.addTool(app_1.removeAppTool);
 }
-addTool(app_1.addAppMemberTool);
-addTool(app_1.removeAppMemberTool);
-addTool(app_1.scaffoldHailerAppTool);
-addTool(app_1.publishHailerAppTool);
+core.addTool(app_1.addAppMemberTool);
+core.addTool(app_1.removeAppMemberTool);
+core.addTool(app_1.scaffoldHailerAppTool);
+core.addTool(app_1.publishHailerAppTool);
 // Marketplace template tools
-addTool(app_1.listTemplatesTool);
-addTool(app_1.createTemplateTool);
-addTool(app_1.installTemplateTool);
-addTool(app_1.getTemplateTool);
-addTool(app_1.publishTemplateTool);
-addTool(app_1.getProductTool);
-addTool(app_1.getProductManifestTool);
+core.addTool(app_1.listTemplatesTool);
+core.addTool(app_1.createTemplateTool);
+core.addTool(app_1.installTemplateTool);
+core.addTool(app_1.getTemplateTool);
+core.addTool(app_1.publishTemplateTool);
+core.addTool(app_1.getProductTool);
+core.addTool(app_1.getProductManifestTool);
 // Marketplace app tools
-addTool(app_1.publishAppTool);
-addTool(app_1.installMarketplaceAppTool);
-// Metrics tools
-addTool(metrics_1.queryMetricTool);
-addTool(metrics_1.listMetricsTool);
-addTool(metrics_1.searchWorkspaceForMetricsTool);
-addTool(metrics_1.searchUserForMetricsTool);
-logger.info('All tools registered successfully');
-// Start the appropriate server based on transport mode
-if (isStdioMode && toolRegistry) {
-    // Stdio mode for Claude Desktop
-    (0, stdio_server_1.startStdioServer)(toolRegistry).catch((error) => {
-        logger.error('Failed to start stdio MCP server', error);
-        process.exit(1);
-    });
-}
-else if (core) {
-    // HTTP mode for other clients
-    core.start().catch((error) => {
-        logger.error('Failed to start Hailer MCP application', error);
-        process.exit(1);
-    });
+core.addTool(app_1.publishAppTool);
+core.addTool(app_1.installMarketplaceAppTool);
+// Bot-internal tools - dynamically imported only when MCP_CLIENT_ENABLED=true
+// This allows npm package to work without bot-config and bug-fixer modules
+if (config_1.environment.MCP_CLIENT_ENABLED) {
+    // Dynamic import bot-config tools
+    const { listBotsConfigTool, enableBotTool, disableBotTool, checkSpecialistStatusTool } = require('./bot-config');
+    core.addTool(listBotsConfigTool);
+    core.addTool(enableBotTool);
+    core.addTool(disableBotTool);
+    core.addTool(checkSpecialistStatusTool);
+    // Dynamic import bug-fixer tools
+    const { 
+    // Low-level tools
+    bugFixerFindAppTool, bugFixerListFilesTool, bugFixerReadFileTool, bugFixerWriteFileTool, bugFixerApplyFixTool, bugFixerRunBuildTool, bugFixerGitStatusTool, bugFixerGitPullTool, bugFixerGitCommitTool, bugFixerGitPushTool, bugFixerGitRevertTool, bugFixerPublishAppTool, 
+    // High-level workflow tools (LLM-driven)
+    bugFixerAnalyzeBugTool, bugFixerStartFixTool, bugFixerMarkDeclinedTool, bugFixerPublishFixTool, bugFixerRetryFixTool, markBugDeclinedTool, markBugFixedTool } = require('./plugins/bug-fixer');
+    // Low-level tools
+    core.addTool(bugFixerFindAppTool);
+    core.addTool(bugFixerListFilesTool);
+    core.addTool(bugFixerReadFileTool);
+    core.addTool(bugFixerWriteFileTool);
+    core.addTool(bugFixerApplyFixTool);
+    core.addTool(bugFixerRunBuildTool);
+    core.addTool(bugFixerGitStatusTool);
+    core.addTool(bugFixerGitPullTool);
+    core.addTool(bugFixerGitCommitTool);
+    core.addTool(bugFixerGitPushTool);
+    core.addTool(bugFixerGitRevertTool);
+    core.addTool(bugFixerPublishAppTool);
+    // High-level workflow tools (LLM-driven)
+    core.addTool(bugFixerAnalyzeBugTool);
+    core.addTool(bugFixerStartFixTool);
+    core.addTool(bugFixerMarkDeclinedTool);
+    core.addTool(bugFixerPublishFixTool);
+    core.addTool(bugFixerRetryFixTool);
+    core.addTool(markBugDeclinedTool);
+    core.addTool(markBugFixedTool);
+    logger.debug('Bot-internal tools registered (MCP_CLIENT_ENABLED=true)');
 }
-// Export core for testing and external access (may be null in stdio mode)
+logger.debug('All tools registered successfully');
+// Start the application
+core.start().catch((error) => {
+    logger.error('Failed to start Hailer MCP application', error);
+    process.exit(1);
+});
+// Export core for testing and external access
 exports.default = core;
 //# sourceMappingURL=app.js.map

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

@@ -0,0 +1,26 @@
+/**
+ * Bot Config Reader
+ *
+ * Simple config reader for .bot-config/*.json files.
+ * Extracts orchestrator credentials into a flat BotConfig interface.
+ */
+export interface BotConfig {
+    workspaceId: string;
+    workspaceName: string;
+    email: string;
+    password: string;
+    displayName?: string;
+    enabled: boolean;
+    apiHost: string;
+}
+/**
+ * Load all bot configs from .bot-config/*.json files.
+ * Extracts orchestrator credentials into flat BotConfig objects.
+ */
+export declare function loadBotConfigs(): BotConfig[];
+/**
+ * Save a BotConfig to .bot-config/{workspaceId}.json.
+ * Preserves the existing file structure, updating orchestrator credentials.
+ */
+export declare function saveBotConfig(config: BotConfig): void;
+//# sourceMappingURL=bot-config.d.ts.map