@hailer/mcp 1.2.1 → 2.0.0-beta.10

package/.claude/commands/integration-squad.md

@@ -1,82 +0,0 @@
----
-description: Build backend integrations with schema discovery and automation
-argument-hint: "integration description"
-allowed-tools: Task, Bash, Read
----
-# Integration Squad
-
-Sequential pipeline: Schema discovery, build integration, then verify with tests.
-
-**Roles:**
-1. **Data Reader** - Schema discovery (workflow fields, types, IDs)
-2. **Automation Builder** - Build integration (monolith webhooks, scheduled jobs, automations)
-3. **Test Runner** - Test runner (verify integration with tests)
-
-**Goal:** $ARGUMENTS
-
-## Protocol
-
-### Step 1: Schema Discovery
-
-Start with schema discovery to gather workflow schema and field IDs needed for the integration:
-
-```
-Task(prompt="Load sdk-ws-config-skill for understanding workspace structure.\n\nList all workflows and their fields relevant to: $ARGUMENTS. Include field IDs, types, and any existing integrations. Also identify webhook URLs and activity phase names needed.")
-```
-
-Wait for result. Save the schema output - the automation builder needs these IDs.
-
-### Step 2: Build Integration
-
-Spawn an automation builder with the schema context:
-
-```
-Task(prompt="Load hailer-monolith-automations skill for building integrations.\n\nBuild a backend integration for: $ARGUMENTS.\n\nWorkflow schema from data reader:\n[PASTE SCHEMA DISCOVERY OUTPUT - workflow IDs, field IDs, types, phases]\n\nImplement in the hailer-integration monolith. Use correct IDs for webhooks, scheduled jobs, or automations.")
-```
-
-Wait for result. If `"status": "ready_to_push"`:
-- Run the push commands provided
-
-### Step 3: Test Integration
-
-Spawn a test runner to verify the integration works:
-
-```
-Task(prompt="Load testing-patterns skill for integration testing.\n\nTest the integration for: $ARGUMENTS.\n\nTest coverage needed:\n- Webhook payload validation (if webhook)\n- Scheduled job execution (if scheduled)\n- Activity creation/phase transitions\n- Error handling and edge cases\n\nRun tests and report pass/fail counts.")
-```
-
-Wait for result. If tests fail, report which ones and offer to have the automation builder fix issues.
-
-### Step 4: Report
-
-```markdown
-## Integration Squad Complete
-
-### Data Reader (Schema Discovery)
-- Workflows found: [list]
-- Fields mapped: [count]
-- Phases identified: [list]
-- Existing integrations: [list or "none"]
-
-### Automation Builder
-- Integration type: [webhook/scheduled/automation]
-- Files created/modified: [list]
-- Endpoints: [list if webhook]
-- Commands run: [list]
-
-### Test Runner
-- Tests: X passed, X failed
-- Build: Pass/Fail
-- [Failed test details if any]
-
-### Next Steps
-- Deploy to staging environment
-- Test end-to-end in Hailer
-- Monitor for errors in production logs
-```
-
-## Notes
-
-- Data Reader must run first to get real IDs - never let automation builder guess IDs
-- Each agent in the pipeline depends on output from the previous step
-- If tests fail, the automation builder may need to revise the integration code

package/.claude/commands/janitor-squad.md

@@ -1,167 +0,0 @@
----
-description: Deep project cleanup - code, config, and data patterns
-argument-hint: [scope or blank for full project]
-allowed-tools: Task, Bash
----
-# Janitor Squad
-
-Deep project cleanup across code, configuration, and data. Discovers dead patterns and auto-fixes clear-cut removals.
-
-**Roles:**
-- **Dead Code Inspector** - Dead code detection (unused imports, unreachable code, type errors via LSP)
-- **Config Auditor** - Configuration audit (deprecated fields, broken references, unused workflows)
-- **Data Analyzer** - Data analysis (unpopulated fields, zero-activity workflows, silent insights)
-- **Code Fixer** - Auto-fix confirmed dead code and unused imports (fix loop)
-- **Code Simplifier** - Simplify complex code blocks identified during discovery (fix loop)
-
-**Target:** $ARGUMENTS (if blank, scan full project)
-
-**Changed files:** Orchestrator runs `git diff --name-only HEAD` to scope if needed.
-
-## Protocol
-
-### Step 1: Determine Scope
-
-If `$ARGUMENTS` has specific files/directories, use those as the target.
-Otherwise, scan the entire project.
-
-If `$ARGUMENTS` contains `--code-only`:
-- Skip Config Auditor and Data Analyzer
-- Only run Dead Code Inspector in discovery phase
-
-If `$ARGUMENTS` contains `--config-only`:
-- Skip Dead Code Inspector and Data Analyzer
-- Only run Config Auditor in discovery phase
-
-If `$ARGUMENTS` contains `--report-only`:
-- Skip all fix loop iterations
-- Report findings only (no auto-fixes)
-
-### Step 2: Launch Discovery Agents in Parallel
-
-**Set:** `iteration = 1`
-
-Spawn all three discovery agents simultaneously using multiple Task tool calls in a single message:
-
-**Dead Code Inspector:**
-```
-Task(prompt="Load lsp-setup skill for code inspection.\n\nInspect the project for dead code patterns: [TARGET]. Find:\n- Unused imports\n- Unreachable code blocks\n- Unused variables and functions\n- Type errors\n\nUse LSP if available, fall back to tsc/eslint. Return detailed findings grouped by file.")
-```
-
-**Config Auditor:**
-```
-Task(prompt="Audit workspace configuration for zombie patterns: [TARGET]. Check:\n- Deprecated fields in workspace/fields.ts\n- Broken field references in phases\n- Unused workflows (defined but zero activities)\n- Broken enum references\n- Orphaned configuration entries\n\nReturn issues grouped by category with severity.")
-```
-
-**Data Analyzer:**
-```
-Task(prompt="Load sdk-insight-queries skill for data analysis.\n\nAnalyze data patterns in workflows: [TARGET]. Find:\n- Fields that are defined but never populated (zero values across all activities)\n- Workflows with zero activities (created but unused)\n- Insights that return empty data (broken or obsolete)\n- Calculated fields that never execute\n- Orphaned data patterns\n\nReturn findings with field IDs, workflow IDs, and impact estimates.")
-```
-
-### Step 3: Categorize Findings
-
-Collect results from all three agents. Categorize each finding as:
-
-**AUTO-FIXABLE** (Code Fixer can safely remove):
-- Unused imports identified by Dead Code Inspector
-- Dead code blocks with no side effects
-- Workflow definitions with zero activities (from Data Analyzer + Config Auditor)
-- Deprecated enum references (from Config Auditor)
-- Never-populated fields that can be safely archived (from Data Analyzer + Config Auditor)
-
-**NEEDS-HUMAN-REVIEW** (escalate to user):
-- Architecture concerns
-- Fields that are rarely used but intentional
-- Complex logic entangled with dead code
-- Data cleanup that affects reporting history
-- Performance optimizations requiring design changes
-
-### Step 4: Auto-Fix Loop (if auto-fixable items found AND `--report-only` not set AND `iteration < 3`)
-
-If critical auto-fixable items exist, spawn two agents to clean up. If the Code Fixer's fixes introduce new issues detected by re-audit, escalate remaining issues to user after max 2 iterations.
-
-**Code Fixer:**
-```
-Task(prompt="Remove confirmed dead code and unused imports from the project:\n\n[LIST AUTO-FIXABLE ITEMS WITH FILE PATHS AND LINE NUMBERS]\n\nFrom Dead Code Inspector:\n- [Unused imports with files]\n- [Dead code blocks with files]\n\nFrom Config Auditor:\n- [Deprecated enum references with files]\n- [Unused workflow definitions with IDs]\n\nFrom Data Analyzer:\n- [Never-populated field definitions with IDs]\n\nApply minimal removals only. Do not refactor or improve beyond confirmed dead patterns.")
-```
-
-**Code Simplifier:**
-```
-Task(prompt="After dead code removal, simplify complex code blocks identified as difficult to maintain: [TARGET].\n\nFocus on:\n- Variable naming clarity\n- Function complexity reduction\n- Comment clarity around remaining logic\n- Code organization in affected files\n\nReturn refactoring suggestions with before/after examples.")
-```
-
-After both finish:
-- Increment `iteration`
-- Go back to **Step 2** to re-run all discovery agents
-- On re-discovery, tell agents to verify previous issues are resolved
-- Max 2 re-check iterations (3 total discovery runs)
-
-### Step 5: Report
-
-```markdown
-## Janitor Squad Report
-
-### Loop Summary
-- Discovery iterations: [count]
-- Auto-fixes applied: [yes/no]
-- Items removed: [count by category]
-
-### Dead Code Inspector
-- Unused imports: X (Y auto-removed)
-- Dead code blocks: X (Y auto-removed)
-- Type errors: X
-- [Remaining issues grouped by file]
-
-### Config Auditor
-- Deprecated fields: X
-- Broken references: X (Y auto-removed)
-- Unused workflows: X (Y auto-removed)
-- Orphaned config: X
-- [Remaining issues grouped by category]
-
-### Data Analyzer
-- Never-populated fields: X (Y marked for archival)
-- Zero-activity workflows: X (Y removed)
-- Silent insights: X
-- Orphaned data patterns: X
-- [Remaining items grouped by workflow]
-
-### Auto-Fixes Applied
-[If any fixes were made:]
-- [File/ID]: [what was removed/archived]
-- [File/ID]: [what was removed/archived]
-
-### Remaining Issues (Manual Action Needed)
-[Issues that require human review]
-- [Category]: [Details]
-
-### Recommended Cleanup Order
-1. [Remove these orphaned items first]
-2. [Archive these fields next]
-3. [Review these design concerns]
-
-### Summary
-[Overall health assessment]
-[Estimated time to apply remaining cleanup]
-```
-
-If any agent fails or times out, report partial results from successful agents, note which failed, and offer to re-run individually.
-
-## Options
-
-| Flag | Effect |
-|------|--------|
-| `--code-only` | Skip Config Auditor and Data Analyzer, just code cleanup via Dead Code Inspector |
-| `--config-only` | Skip Dead Code Inspector and Data Analyzer, just workspace config audit via Config Auditor |
-| `--report-only` | Report findings only, no auto-fix loop (discovery phase only) |
-| `--bg` | Run all discovery agents in background mode |
-
-If `--bg` is present, launch all discovery agents with `run_in_background: true` and tell the user they'll be notified when discovery is complete, then proceed with fix loop when they're ready.
-
-## Notes
-
-- Max 2 re-discovery iterations (3 total) to prevent infinite loops
-- Code Fixer only removes clear-cut dead code - ambiguous items go to user review
-- Data cleanup (Data Analyzer findings) may affect reports/history - always prompt user before removal
-- Each re-discovery is a full parallel sweep across all enabled agents
-- The `--report-only` flag gives discovery results without auto-fixes

package/.claude/commands/onboard-squad.md

@@ -1,130 +0,0 @@
----
-description: Bootstrap a new Hailer project end-to-end
-argument-hint: "project description or PRD path"
-allowed-tools: Task, Bash, Read
----
-# Onboard Squad
-
-Sequential pipeline: Create workspace infrastructure, scaffold the app, and verify everything is wired correctly.
-
-**Roles:**
-1. **Workflow Config** - Workflow configuration (create workflows, fields, phases, teams, groups)
-2. **Function Fields** - Calculated fields and nameFunction
-3. **App Builder** - Scaffold first app with basic CRUD interface
-4. **Config Auditor** - Audit configuration accuracy and field references
-
-**Goal:** $ARGUMENTS
-
-## Protocol
-
-### Step 1: Parse Requirements
-
-Parse `$ARGUMENTS` to determine input type:
-
-- **If it's a file path** (e.g., `docs/prd-onboarding.md`): Read it for requirements
-- **Otherwise:** Use it as a project description
-
-If `$ARGUMENTS` is a file path, read it first before proceeding to Workflow Config.
-
-### Step 2: Workflow Config
-
-Spawn a workflow config agent to create workspace infrastructure:
-
-```
-Task(prompt="Load sdk-ws-config-skill for workspace setup.\n\nBootstrap a new Hailer project: $ARGUMENTS\n\nCreate: workflows (at least 1), fields for each workflow, phases, teams, and groups as needed.")
-```
-
-Wait for result. If the agent returns `"status": "ready_to_push"`:
-- Run the push commands provided (e.g., `npm run fields-push:force`)
-- Then run `npm run pull` to refresh local workspace with new IDs
-- **Important:** Workflow config ALWAYS spawns a function fields agent for nameFunction. Check if the result indicates it was spawned and created nameFunction. If yes, function fields work is done - skip to Step 3.
-
-### Step 3: Function Fields - Conditional
-
-Only spawn if workflow config indicates additional function fields are needed beyond what was created by the auto-spawn.
-
-If needed, spawn a function fields agent:
-
-```
-Task(prompt="Load sdk-function-fields and sdk-ws-config-skill skills for creating calculated fields.\n\nCreate additional function fields for workflows created in: [INSERT WORKFLOW CONFIG GOAL].\n\nWorkflow config created these workflows: [SUMMARIZE WORKFLOW CONFIG RESULT - workflow names, IDs, field counts].\n\nFunction fields already created by workflow config: [FROM WORKFLOW CONFIG RESULT].")
-```
-
-Wait for result. If `"status": "ready_to_push"`:
-- Run the push commands
-- Run `npm run pull` to refresh workspace
-
-### Step 4: App Scaffold
-
-Spawn an app builder to build the first app using the new workspace:
-
-```
-Task(prompt="Load hailer-app-builder and hailer-design-system skills for app development.\n\nScaffold the first Hailer app for this new project: $ARGUMENTS\n\nWorkspace created by workflow config: [SUMMARIZE WORKFLOW CONFIG RESULT - workflow names, IDs, field counts]. You: read workspace/ directly to discover exact field IDs, types, and team configurations. Do not guess IDs.\n\nBuild a basic CRUD interface using @hailer/app-sdk and Chakra UI. Start with the primary workflow. Use the Hailer Design System.\n\nNote: Assume Local Dev app exists (orchestrator checks this before spawning you). Build for local development at http://localhost:3000.")
-```
-
-Wait for result. If the builder returns `"status": "ready_to_push"`:
-- Run the push commands
-
-### Step 5: Config Audit
-
-Spawn a config auditor to verify everything is configured correctly:
-
-```
-Task(prompt="Audit this new Hailer project setup:\n\n1. Verify CLAUDE.md accuracy (check that project type detection works)\n2. Verify workspace configuration: workflows, fields, phases, teams all match workspace/ files\n3. Verify field references in the new app match workspace/ field definitions\n4. Check for missing imports, incorrect IDs, or type mismatches\n5. Verify that nameFunction is set on the primary workflow\n\nProject goal: $ARGUMENTS\n\nReport any misconfigurations. If iteration <= 1, recommend fixes to the orchestrator.")
-```
-
-**Loop Control:**
-- If config auditor finds no critical issues: proceed to Step 6 (report)
-- If config auditor finds issues AND `iteration <= 1`:
-  - Increment `iteration`
-  - Determine which agent to fix it (usually Workflow Config or App Builder)
-  - Run appropriate agent with the issues to fix
-  - Return to Step 5 (config audit re-checks)
-- If config auditor finds issues AND `iteration > 1`: escalate to user in Step 6
-
-### Step 6: Report
-
-```markdown
-## Onboard Squad Complete
-
-**Project Goal:** $ARGUMENTS
-
-### Workspace Setup
-- Workflows created: [list with IDs]
-- Fields created: [count]
-- Phases: [count]
-- Teams: [count]
-- Function fields auto-spawn: [nameFunction created? Y/N]
-
-### Function Fields
-- Additional function fields created: [list or "None needed"]
-- Skipped: [reason if skipped]
-
-### App Scaffold
-- App path: [path to new app]
-- Build status: Pass/Fail
-- Files created: [count/list]
-- Local dev setup: [check local dev app name]
-
-### Config Audit
-- Critical issues found: [count] or "None"
-- Status: VERIFIED / NEEDS FIXES (if iteration > 1, see below)
-
-[If iteration > 1 - escalated:]
-### Remaining Issues
-[List issues config auditor found that weren't resolved in 1 fix iteration]
-- Manual fixes recommended: [hints]
-
-### Next Steps
-1. Run `npm run dev` to test the app locally
-2. Ensure "Local Dev" app exists in Hailer workspace
-3. Test the app inside Hailer iframe at http://localhost:3000
-4. Run `npm run pull` to ensure workspace/ is fully up to date
-```
-
-## Notes
-
-- Each agent in the pipeline needs IDs from the previous step. Always `npm run pull` between Workflow Config→Function Fields→App Builder to refresh local workspace.
-- Workflow config auto-spawns function fields agent for nameFunction. Check the result - only spawn function fields separately in Step 3 if additional function fields are needed.
-- App builder needs real workflow and field IDs from workspace/ - always read the files and paste actual IDs, never let it guess.
-- Config auditor's audit is the quality gate. If issues are found and you've iterated once, escalate remaining issues to the user rather than looping infinitely.
-- Set `iteration = 1` at the start. Increment after each config audit if fixes are attempted.

package/.claude/commands/swarm.md

@@ -1,210 +0,0 @@
----
-description: Orchestrator-driven parallel swarm for large-scale tasks
-argument-hint: "description of what to do across many items"
-allowed-tools: Task, Bash, Read, Glob
----
-
-# Swarm
-
-Orchestrator-driven parallel execution: analyze the task, discover work items, pick agents, split into chunks, dispatch workers, aggregate results.
-
-**Goal:** $ARGUMENTS
-
-## Protocol
-
-### Step 1: Analyze the Task
-
-Read `$ARGUMENTS` and determine:
-
-- **What needs to be done?** (review, edit, check, migrate, update, clean up)
-- **What are the work items?** (files, activities, workflows, agents, skills, configs)
-- **What scope?** (explicit path/glob from user, or infer from task description)
-
-If the scope is unclear, use Glob or Bash to discover items:
-
-```
-# Files
-Glob("src/**/*.ts")
-Glob(".claude/agents/*.md")
-Glob("workspace/*/fields.ts")
-
-# Activities (use data reader to count/list)
-Task(prompt="Count and list activity IDs for [workflow]")
-```
-
-If fewer than 5 items are discovered, **abort swarm** and suggest running a regular squad or single agent instead. Swarm is for scale.
-
-### Step 2: Pick Agent(s)
-
-Based on the task type, select the right agent(s):
-
-| Task Type | Role | Examples |
-|-----------|-------|---------|
-| Code review, security audit | **Code Reviewer** | "review for bugs", "security check", "find vulnerabilities" |
-| Dead code, unused imports, type errors | **Code Inspector** | "find dead code", "check types", "unused imports" |
-| Small edits, string replacements, rule additions | **Code Fixer** | "add header to each file", "replace X with Y", "update rule" |
-| Code cleanup, simplification | **Code Simplifier** | "clean up", "simplify", "refactor for clarity" |
-| Config audit, structure validation | **Config Auditor** | "check config", "validate structure", "audit settings" |
-| Data state checks, field validation | **Data Reader** | "check all activities", "verify field values", "find missing data" |
-| Query patterns, data analysis | **Data Analyzer** | "analyze patterns", "find anomalies across workflows" |
-| Activity updates, bulk mutations | **Activity Writer** | "update all activities", "move to phase", "set field values" |
-
-**Multi-agent swarms:** If the task spans multiple domains, assign different agent types to different items. For example, "clean up the project" might use Code Inspector for `.ts` files, Config Auditor for config files, and Code Simplifier for app components.
-
-### Step 3: Calculate Workers
-
-```
-items_count = total discovered items
-items_per_worker = 10 (default)
-max_workers = 5
-
-worker_count = min(ceil(items_count / items_per_worker), max_workers)
-```
-
-Split items into `worker_count` chunks. Try to keep chunks roughly equal size.
-
-For multi-agent swarms, group items by agent type first, then chunk within each type.
-
-### Step 4: Dispatch Workers
-
-Launch all workers in parallel using multiple Task tool calls in a single message. All workers run in background (`run_in_background: true`).
-
-Each worker gets:
-
-```
-Task(
-  run_in_background: true,
-  prompt="SWARM WORKER [N] of [TOTAL]
-
-TASK: [User's description from $ARGUMENTS]
-
-YOUR ITEMS ([count]):
-- [item 1]
-- [item 2]
-- [item 3]
-...
-
-Process each item and report results in this format:
-
-RESULTS:
-- [item]: [status] - [details]
-- [item]: [status] - [details]
-
-SUMMARY:
-- Processed: [count]
-- Passed: [count]
-- Issues found: [count]
-- Failed: [count]")
-```
-
-Tell the user:
-```
-Launched [worker_count] workers across [items_count] items.
-Running in background - what else do you want to work on?
-```
-
-### Step 5: Collect Results
-
-When workers complete (check via Read on output files or TaskOutput), aggregate all results.
-
-If any worker failed or timed out:
-- Report which items were in the failed worker's batch
-- Offer to retry just those items
-
-### Step 6: Report
-
-```markdown
-## Swarm Report
-
-### Task
-[User's description]
-
-### Execution
-- **Items:** [total count]
-- **Workers:** [worker count] x [role type(s)]
-- **Duration:** [time from dispatch to last worker completion]
-
----
-
-### Results by Worker
-
-#### Worker 1 ([role type]) - [X items]
-- [item]: [status] - [details]
-- [item]: [status] - [details]
-...
-
-#### Worker 2 ([role type]) - [X items]
-...
-
----
-
-### Aggregate Summary
-
-| Status | Count |
-|--------|-------|
-| Passed / Clean | X |
-| Issues Found | X |
-| Failed / Error | X |
-
-### Issues Found
-[Grouped and deduplicated list of all issues across all workers]
-
-1. **[item]**: [issue description]
-2. **[item]**: [issue description]
-...
-
-### Failed Items
-[If any workers failed, list their items for retry]
-
-### Next Steps
-- [Suggested follow-up based on results]
-- [If issues found: suggest /hotfix-squad or /review-squad to fix]
-- [If edits made: suggest /review-squad to verify]
-```
-
-## Options
-
-| Flag | Effect |
-|------|--------|
-| `--workers=N` | Override worker count (default: auto-calculated, max 5) |
-| `--dry-run` | Show what would be dispatched without actually running |
-| `--no-bg` | Run workers in foreground (wait for all to complete) |
-
-## Examples
-
-```
-# Review all source files for security
-/swarm "review all TypeScript files in src/ for security vulnerabilities"
-→ Discovers 47 .ts files, spawns 5 code reviewer workers
-
-# Bulk edit agent files
-/swarm "add a '## Version History' section to every agent file"
-→ Discovers 27 agent .md files, spawns 3 code fixer workers
-
-# Validate workspace configs
-/swarm "check all workflow field definitions for missing descriptions"
-→ Discovers 12 fields.ts files, spawns 2 data reader workers
-
-# Multi-agent cleanup
-/swarm "clean up the entire apps/ directory"
-→ Discovers 34 files: 20 .tsx → Code Simplifier workers, 8 .ts → Code Inspector workers, 6 configs → Config Auditor workers
-→ Spawns 5 workers across 3 roles
-
-# Data validation
-/swarm "verify all Customer activities have a valid email field"
-→ Data Reader counts 200 customers, spawns 5 data reader workers (40 each)
-
-# Dry run to preview
-/swarm "update all skills to use consistent headers" --dry-run
-→ Shows: "Would dispatch 4 code fixer workers across 32 skill files"
-```
-
-## Notes
-
-- Minimum 5 items to trigger swarm (below that, use a regular agent)
-- Default max 5 workers to avoid overwhelming the system
-- Workers run in background by default so user can keep working
-- Multi-agent swarms naturally emerge from the role-based routing logic
-- For write operations (Activity Writer, Code Fixer), consider running --dry-run first
-- Swarm vs Squad: Swarm is raw parallel execution without quality gates. Workers operate independently. Squads have convergence, synthesis, and loops. Use swarm for bulk independent items, squads for coordinated workflows.
-- Swarm + squad can combine: `/swarm "review src/"` finds issues, then user can run `/hotfix-squad` on results. This is a manual handoff - user confirms.

package/.claude/commands/tool-builder.md

@@ -1,39 +0,0 @@
----
-description: Activate tool-builder mode to implement a new MCP tool
----
-
-# Tool Builder Mode
-
-Loading `tool-builder` skill for MCP tool patterns...
-
-**What tool should I build?**
-
-Please provide:
-
-- **Tool Name**: `tool_name` (snake_case)
-- **Purpose**: What does it do?
-- **API Endpoint**: `v3.endpoint.method`
-- **Request Format**: `[arg1, arg2]`
-- **Response Format**: What the API returns
-- **Target File**: Which file in `src/mcp/tools/`?
-- **Tool Group**: READ | WRITE | PLAYGROUND
-
----
-
-**Example:**
-```
-Tool Name: list_insights
-Purpose: List all insights in workspace
-API Endpoint: v3.insight.list
-Request: [workspaceId]
-Response: { insights: [{_id, name, query, sources}] }
-Target File: insight.ts
-Tool Group: PLAYGROUND
-```
-
-I'll:
-1. Load tool-builder skill
-2. Read existing patterns in target file
-3. Implement the tool
-4. Register in src/app.ts
-5. Report what was created