tascan-mcp 1.0.1 → 2.1.0

package/README.md

@@ -1,153 +1,232 @@
-# MCP Registry
+# TaScan MCP Server
 
-The MCP registry provides MCP clients with a list of MCP servers, like an app store for MCP servers.
+AI agent integration for [TaScan](https://tascan.io) — the closed-loop autonomous operations protocol. Manage projects, events, tasks, workers, QR codes, templates, completion reports, and AI-powered issue resolution through Claude, GitHub Copilot, or any MCP-compatible AI client.
 
-[**📤 Publish my MCP server**](docs/modelcontextprotocol-io/quickstart.mdx) | [**⚡️ Live API docs**](https://registry.modelcontextprotocol.io/docs) | [**👀 Ecosystem vision**](docs/design/ecosystem-vision.md) | 📖 **[Full documentation](./docs)**
+**Scan. Task. Done.**
 
-## Development Status
+## What is TaScan?
 
-**2025-10-24 update**: The Registry API has entered an **API freeze (v0.1)** 🎉. For the next month or more, the API will remain stable with no breaking changes, allowing integrators to confidently implement support. This freeze applies to v0.1 while development continues on v0. We'll use this period to validate the API in real-world integrations and gather feedback to shape v1 for general availability. Thank you to everyone for your contributions and patience—your involvement has been key to getting us here!
+TaScan is a zero-download task assignment and verification platform for physical-world work. Workers scan a QR code, complete tasks with photo verification, and managers get real-time completion reports — no app download, no login, no training required.
 
-**2025-09-08 update**: The registry has launched in preview 🎉 ([announcement blog post](https://blog.modelcontextprotocol.io/posts/2025-09-08-mcp-registry-preview/)). While the system is now more stable, this is still a preview release and breaking changes or data resets may occur. A general availability (GA) release will follow later. We'd love your feedback in [GitHub discussions](https://github.com/modelcontextprotocol/registry/discussions/new?category=ideas) or in the [#registry-dev Discord](https://discord.com/channels/1358869848138059966/1369487942862504016) ([joining details here](https://modelcontextprotocol.io/community/communication)).
+When something breaks, AI analyzes the issue, generates fix instructions, and dispatches them to the right worker — closing the loop autonomously in under 10 seconds.
 
-Current key maintainers:
-- **Adam Jones** (Anthropic) [@domdomegg](https://github.com/domdomegg)  
-- **Tadas Antanavicius** (PulseMCP) [@tadasant](https://github.com/tadasant)
-- **Toby Padilla** (GitHub) [@toby](https://github.com/toby)
-- **Radoslav (Rado) Dimitrov** (Stacklok) [@rdimitrov](https://github.com/rdimitrov)
+Industries: live events, construction, hospitality, warehousing, property management, healthcare, aviation, FEMA disaster response, and more.
 
-## Contributing
+**Patent Pending** — USPTO #63/995,189 & #63/996,023
 
-We use multiple channels for collaboration - see [modelcontextprotocol.io/community/communication](https://modelcontextprotocol.io/community/communication).
+## Quickest Start: Claude.ai / Claude Mobile
 
-Often (but not always) ideas flow through this pipeline:
+No install required. Add TaScan as a custom connector in Claude:
 
-- **[Discord](https://modelcontextprotocol.io/community/communication)** - Real-time community discussions
-- **[Discussions](https://github.com/modelcontextprotocol/registry/discussions)** - Propose and discuss product/technical requirements
-- **[Issues](https://github.com/modelcontextprotocol/registry/issues)** - Track well-scoped technical work  
-- **[Pull Requests](https://github.com/modelcontextprotocol/registry/pulls)** - Contribute work towards issues
+1. **Settings > Connectors > Add custom connector**
+2. Enter: `https://tascan-live-event.netlify.app/mcp`
+3. First time you use a tool, sign in with your TaScan email and password
 
-### Quick start:
+That's it. Works on claude.ai and Claude mobile. Same sign-in experience as GitHub, Netlify, and Supabase connectors.
 
-#### Pre-requisites
+---
 
-- **Docker**
-- **Go 1.24.x**
-- **ko** - Container image builder for Go ([installation instructions](https://ko.build/install/))
-- **golangci-lint v2.4.0**
-
-#### Running the server
+## Installation (Claude Desktop / Claude Code)
 
 ```bash
-# Start full development environment
-make dev-compose
+npm install tascan-mcp
 ```
 
-This starts the registry at [`localhost:8080`](http://localhost:8080) with PostgreSQL. The database uses ephemeral storage and is reset each time you restart the containers, ensuring a clean state for development and testing.
+Or run directly with npx:
 
-**Note:** The registry uses [ko](https://ko.build) to build container images. The `make dev-compose` command automatically builds the registry image with ko and loads it into your local Docker daemon before starting the services.
+```bash
+npx tascan-mcp
+```
 
-By default, the registry seeds from the production API with a filtered subset of servers (to keep startup fast). This ensures your local environment mirrors production behavior and all seed data passes validation. For offline development you can seed from a file without validation with `MCP_REGISTRY_SEED_FROM=data/seed.json MCP_REGISTRY_ENABLE_REGISTRY_VALIDATION=false make dev-compose`.
+## Configuration
 
-The setup can be configured with environment variables in [docker-compose.yml](./docker-compose.yml) - see [.env.example](./.env.example) for a reference.
+### Environment Variables
 
-<details>
-<summary>Alternative: Running a pre-built Docker image</summary>
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `TASCAN_API_KEY` | Yes | Your TaScan API key (generate in Admin Portal > Team > API Keys) |
+| `TASCAN_API_URL` | No | API base URL (default: `https://tascan-live-event.netlify.app/api/v1`) |
 
-Pre-built Docker images are automatically published to GitHub Container Registry:
+### Claude Desktop
 
-```bash
-# Run latest stable release
-docker run -p 8080:8080 ghcr.io/modelcontextprotocol/registry:latest
+Add to your Claude Desktop config file (`claude_desktop_config.json`):
 
-# Run latest from main branch (continuous deployment)
-docker run -p 8080:8080 ghcr.io/modelcontextprotocol/registry:main
+```json
+{
+  "mcpServers": {
+    "tascan": {
+      "command": "npx",
+      "args": ["-y", "tascan-mcp"],
+      "env": {
+        "TASCAN_API_KEY": "your-api-key-here"
+      }
+    }
+  }
+}
+```
 
-# Run specific release version
-docker run -p 8080:8080 ghcr.io/modelcontextprotocol/registry:v1.0.0
+### Claude Code
 
-# Run development build from main branch
-docker run -p 8080:8080 ghcr.io/modelcontextprotocol/registry:main-20250906-abc123d
+```bash
+claude mcp add tascan -- npx -y tascan-mcp
 ```
 
-**Available tags:** 
-- **Releases**: `latest`, `v1.0.0`, `v1.1.0`, etc.
-- **Continuous**: `main` (latest main branch build)
-- **Development**: `main-<date>-<sha>` (specific commit builds)
+Then set your API key in the environment.
 
-</details>
+### Remote (claude.ai / Claude Mobile)
 
-#### Publishing a server
+TaScan MCP is also available as a remote server — no install, no API key needed:
 
-To publish a server, we've built a simple CLI. You can use it with:
+```
+https://tascan-live-event.netlify.app/mcp
+```
 
-```bash
-# Build the latest CLI
-make publisher
+Add as a custom connector in Claude (Settings > Connectors). When you first use a tool, you'll be redirected to sign in with your TaScan email and password — just like connecting GitHub or Netlify. OAuth 2.0 with PKCE handles everything automatically.
+
+## Tools (27)
+
+### Projects
+| Tool | Description | Type |
+|------|-------------|------|
+| `tascan_list_projects` | List all projects in the organization | Read |
+| `tascan_get_project` | Get details of a specific project | Read |
+| `tascan_create_project` | Create a new project | Create |
+| `tascan_update_project` | Update project name, location, status, dates | Update |
+| `tascan_delete_project` | Delete a project and all its contents | Delete |
+
+### Events (Task Lists)
+| Tool | Description | Type |
+|------|-------------|------|
+| `tascan_list_events` | List all events within a project | Read |
+| `tascan_get_event` | Get event details including tasks | Read |
+| `tascan_create_event` | Create a new event in a project | Create |
+| `tascan_update_event` | Update event name, description, modes | Update |
+| `tascan_delete_event` | Delete an event and all its tasks | Delete |
+
+### Tasks
+| Tool | Description | Type |
+|------|-------------|------|
+| `tascan_list_tasks` | List all tasks in an event | Read |
+| `tascan_get_task` | Get task details including completions | Read |
+| `tascan_add_tasks` | Bulk-create tasks in an event | Create |
+| `tascan_update_task` | Update task title, type, flags, order | Update |
+| `tascan_delete_task` | Delete a task and its completions | Delete |
+
+### Workers
+| Tool | Description | Type |
+|------|-------------|------|
+| `tascan_list_workers` | List all workers in the organization | Read |
+| `tascan_create_worker` | Create a new worker profile | Create |
+| `tascan_update_worker` | Update worker name, phone, email | Update |
+
+### Operations
+| Tool | Description | Type |
+|------|-------------|------|
+| `tascan_generate_qr` | Generate a QR code for an event | Create |
+| `tascan_apply_template` | Apply a pre-built template to an event | Create |
+| `tascan_list_templates` | List available task templates | Read |
+| `tascan_get_report` | Get completion report for an event | Read |
+
+### Closed-Loop Autonomous Operations (Patent Pending)
+| Tool | Description | Type |
+|------|-------------|------|
+| `tascan_list_issues` | List field-reported issues with filtering by status, category, severity | Read |
+| `tascan_analyze_issue` | AI classifies issue severity, identifies root cause, and scores urgency | AI |
+| `tascan_recommend_fix` | AI generates ranked remediation tasks with step-by-step instructions | AI |
+| `tascan_dispatch_instruction` | Multi-channel delivery of fix instructions to workers (SMS, push, QR) | Create |
+| `tascan_auto_resolve` | Full closed loop in ONE call — issue in, AI analyzes, fix dispatched, loop closes | AI |
+
+## Usage Examples
+
+### Example 1: Set up a construction site inspection
 
-# Use it!
-./bin/mcp-publisher --help
 ```
+User: Create a construction project for the Downtown Tower site and set up a daily safety inspection with tasks for PPE check, fall protection, scaffolding inspection, and fire extinguisher check. Make all tasks safety checkpoints that require photos.
 
-See [the publisher guide](./docs/modelcontextprotocol-io/quickstart.mdx) for more details.
+Claude will:
+1. Call tascan_create_project with name "Downtown Tower" and location "123 Main St"
+2. Call tascan_create_event with name "Daily Safety Inspection"
+3. Call tascan_add_tasks with 4 safety checkpoint tasks requiring photos
+4. Call tascan_generate_qr to create a scannable QR code for the foreman
+```
 
-#### Other commands
+### Example 2: AI-powered autonomous issue resolution
 
-```bash
-# Run lint, unit tests and integration tests
-make check
 ```
+User: Check if there are any open issues on the Marriott load-in and have TaScan fix them automatically.
 
-There are also a few more helpful commands for development. Run `make help` to learn more, or look in [Makefile](./Makefile).
+Claude will:
+1. Call tascan_list_issues to find open issues
+2. Call tascan_auto_resolve for each issue — AI analyzes root cause, generates fix tasks, and dispatches instructions to the nearest qualified worker via SMS
+3. Report back with resolution status and confidence scores
+```
 
-<!--
-For Claude and other AI tools: Always prefer make targets over custom commands where possible.
--->
+### Example 3: Use templates to quickly deploy an event
 
-## Architecture
+```
+User: We have a warehouse receiving shipment coming in tomorrow. Set up the standard receiving checklist.
+
+Claude will:
+1. Call tascan_list_templates with category "logistics" to find available templates
+2. Call tascan_create_project for the warehouse
+3. Call tascan_create_event for the receiving session
+4. Call tascan_apply_template with the "warehouse-receiving" template slug
+5. Call tascan_generate_qr for the receiving dock crew
+```
 
-### Project Structure
+### Example 4: Analyze and triage field issues
 
 ```
-├── cmd/                     # Application entry points
-│   └── publisher/           # Server publishing tool
-├── data/                    # Seed data
-├── deploy/                  # Deployment configuration (Pulumi)
-├── docs/                    # Documentation
-├── internal/                # Private application code
-│   ├── api/                 # HTTP handlers and routing
-│   ├── auth/                # Authentication (GitHub OAuth, JWT, namespace blocking)
-│   ├── config/              # Configuration management
-│   ├── database/            # Data persistence (PostgreSQL)
-│   ├── service/             # Business logic
-│   ├── telemetry/           # Metrics and monitoring
-│   └── validators/          # Input validation
-├── pkg/                     # Public packages
-│   ├── api/                 # API types and structures
-│   │   └── v0/              # Version 0 API types
-│   └── model/               # Data models for server.json
-├── scripts/                 # Development and testing scripts
-├── tests/                   # Integration tests
-└── tools/                   # CLI tools and utilities
-    └── validate-*.sh        # Schema validation tools
+User: We have 5 open issues on the concert setup. Analyze them all and tell me which ones are most urgent.
+
+Claude will:
+1. Call tascan_list_issues to get all open issues
+2. Call tascan_analyze_issue for each one — AI classifies severity, root cause probability, and urgency score
+3. Rank by urgency and recommend which to auto-resolve vs which need human attention
 ```
 
-### Authentication
+## Task Types
+
+Tasks support multiple response types:
+
+| Type | Description |
+|------|-------------|
+| `checkbox` | Simple done/not-done (default) |
+| `photo` | Requires photo upload to complete |
+| `text` | Free-text response |
+| `number` | Numeric response |
+| `date` | Date selection |
+| `choice` | Multiple choice selection |
+
+Tasks can also be flagged as:
+- **Safety checkpoints** (`is_safety_checkpoint: true`) — highlighted in red, cannot be skipped
+- **Photo required** (`requires_photo: true`) — worker must attach a photo to complete
+
+## Getting an API Key
+
+1. Log in to the [TaScan Admin Portal](https://tascan-live-event.netlify.app)
+2. Navigate to **Team** in the sidebar
+3. Scroll to **API Keys**
+4. Click **Generate API Key**
+5. Copy the key (it's only shown once)
+6. Set it as `TASCAN_API_KEY` in your environment
+
+API keys are scoped to your organization and support rate limiting (60 requests/minute).
+
+## Privacy Policy
+
+TaScan collects and processes task completion data, worker information (name, phone, email), GPS coordinates (with consent), and photos uploaded during task completion. Data is stored securely in Supabase with row-level security policies. API access is authenticated and rate-limited.
 
-Publishing supports multiple authentication methods:
-- **GitHub OAuth** - For publishing by logging into GitHub
-- **GitHub OIDC** - For publishing from GitHub Actions
-- **DNS verification** - For proving ownership of a domain and its subdomains
-- **HTTP verification** - For proving ownership of a domain
+For the full privacy policy, visit: https://tascan.io/faq.html
 
-The registry validates namespace ownership when publishing. E.g. to publish...:
-- `io.github.domdomegg/my-cool-mcp` you must login to GitHub as `domdomegg`, or be in a GitHub Action on domdomegg's repos
-- `me.adamjones/my-cool-mcp` you must prove ownership of `adamjones.me` via DNS or HTTP challenge
+For data deletion requests or privacy inquiries, contact: Michael@TaScan.io
 
-## Community Projects
+## Support
 
-Check out [community projects](docs/community-projects.md) to explore notable registry-related work created by the community.
+- **Email:** Michael@TaScan.io
+- **Website:** https://tascan.io
+- **Issues:** https://github.com/snowbikemike/tascan-mcp/issues
 
-## More documentation
+## License
 
-See the [documentation](./docs) for more details if your question has not been answered here!
+MIT License - Copyright (c) 2026 Michael Edward Love II / Love Productions LLC

package/index.js

@@ -46,7 +46,7 @@ async function apiCall(method, path, body) {
 // ─── Server Setup ──────────────────────────────────────────
 const server = new McpServer({
   name: 'tascan',
-  version: '1.0.0'
+  version: '2.0.0'
 });
 
 
@@ -662,6 +662,204 @@ server.registerTool(
 );
 
 
+// ─── Closed-Loop Autonomous Operations Protocol ───────────
+
+// Tool 23: List Issues (discover issues for analysis)
+server.registerTool(
+  'tascan_list_issues',
+  {
+    title: 'List Issues',
+    description: 'List all issues for a task list (event). Returns open, acknowledged, and resolved issues. Use to discover issues for AI analysis via tascan_analyze_issue.',
+    inputSchema: {
+      list_id: z.string().describe('Task list (event) ID')
+    },
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false
+    }
+  },
+  async ({ list_id }) => {
+    const result = await apiCall('GET', `/lists/${list_id}/issues`);
+    const issues = result.data;
+    if (!issues.length) return { content: [{ type: 'text', text: 'No issues reported for this task list.' }] };
+    let text = `${issues.length} issue(s) found:\n\n`;
+    issues.forEach((iss, i) => {
+      text += `${i+1}. [${iss.status.toUpperCase()}] ${iss.title}\n`;
+      text += `   ID: ${iss.id} | Type: ${iss.type} | Category: ${iss.category} | Severity: ${iss.severity || 'unset'}\n`;
+      if (iss.tasks) text += `   Task: ${iss.tasks.title}\n`;
+      text += `   Reported: ${iss.created_at}\n\n`;
+    });
+    return { content: [{ type: 'text', text }] };
+  }
+);
+
+// Tool 24: Analyze Issue (Step 1 of Closed-Loop — read issue with full context + optional server AI)
+server.registerTool(
+  'tascan_analyze_issue',
+  {
+    title: 'Analyze Issue',
+    description: 'Step 1 of the Closed-Loop Autonomous Operations Protocol. Returns full issue context including worker info, message thread, project history, and recent similar issues for AI reasoning. Supports optional server-side AI analysis via Anthropic API.',
+    inputSchema: {
+      issue_id: z.string().describe('Issue ID to analyze'),
+      server_side_ai: z.boolean().optional().describe('If true, server calls Anthropic API for analysis (default: false)')
+    },
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false
+    }
+  },
+  async ({ issue_id, server_side_ai }) => {
+    if (server_side_ai) {
+      const result = await apiCall('POST', `/issues/${issue_id}/analyze`);
+      const d = result.data;
+      let text = `=== AI ANALYSIS (Server-Side) ===\n`;
+      text += `Issue: ${d.issue_title} (${d.issue_id})\nAnalyzed: ${d.analyzed_at}\n\n`;
+      text += JSON.stringify(d.analysis, null, 2);
+      return { content: [{ type: 'text', text }] };
+    }
+
+    const result = await apiCall('GET', `/issues/${issue_id}`);
+    const d = result.data;
+    let text = `=== ISSUE CONTEXT FOR ANALYSIS ===\n`;
+    text += `Issue: ${d.title}\n`;
+    text += `Type: ${d.type} | Category: ${d.category} | Severity: ${d.severity || 'unset'} | Status: ${d.status}\n`;
+    text += `Description: ${d.description || 'none'}\n`;
+    if (d.tasks) text += `Task: ${d.tasks.title} (${d.tasks.response_type || 'checkbox'})\nTask Description: ${d.tasks.description || 'none'}\n`;
+    if (d.worker) text += `Worker: ${d.worker.name} (ID: ${d.worker.id})\n`;
+    if (d.project) text += `Project: ${d.project.name} | Location: ${d.project.location || 'unknown'}\n`;
+    if (d.injury_data) text += `Injury Data: ${JSON.stringify(d.injury_data)}\n`;
+    text += `Reported: ${d.created_at}\n`;
+    if (d.ai_analysis) text += `\n--- PREVIOUS AI ANALYSIS ---\n${JSON.stringify(d.ai_analysis, null, 2)}\n`;
+    if (d.messages && d.messages.length) {
+      text += `\n--- Message Thread (${d.messages.length}) ---\n`;
+      d.messages.forEach(m => { text += `[${m.sender_type}/${m.sender_name}] ${m.message}\n`; });
+    }
+    if (d.recent_issues && d.recent_issues.length) {
+      text += `\n--- Recent Issues on Same Project (${d.recent_issues.length}) ---\n`;
+      d.recent_issues.forEach(ri => { text += `- [${ri.severity}/${ri.category}] ${(ri.description || '').substring(0, 80)} (${ri.status})\n`; });
+    }
+    return { content: [{ type: 'text', text }] };
+  }
+);
+
+// Tool 25: Recommend Fix (Step 2 — post recommendation + optional structured tasks)
+server.registerTool(
+  'tascan_recommend_fix',
+  {
+    title: 'Recommend Fix',
+    description: 'Step 2 of the Closed-Loop. Post AI recommendation to issue thread. Accepts optional structured_recommendation with task definitions for auto-dispatch. Persisted in AI audit trail.',
+    inputSchema: {
+      issue_id: z.string().describe('Issue ID to recommend a fix for'),
+      recommendation: z.string().describe('AI recommendation text (clear, actionable instructions)'),
+      structured_recommendation: z.any().optional().describe('Structured recommendation object with tasks for dispatch'),
+      ai_agent: z.string().optional().describe('AI agent name (default: TaScan AI)')
+    },
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false
+    }
+  },
+  async ({ issue_id, recommendation, structured_recommendation, ai_agent }) => {
+    const body = { recommendation };
+    if (structured_recommendation) body.structured_recommendation = structured_recommendation;
+    if (ai_agent) body.ai_agent = ai_agent;
+    const result = await apiCall('POST', `/issues/${issue_id}/recommend`, body);
+    const d = result.data;
+    let text = `Recommendation posted to issue "${d.issue_title}":\n`;
+    text += `Project: ${d.project_name} | List: ${d.list_name}\n`;
+    text += `Message ID: ${d.message_id}\n\nRecommendation:\n${d.recommendation}`;
+    if (d.structured_recommendation?.tasks) {
+      text += `\n\nStructured Tasks (${d.structured_recommendation.tasks.length}):`;
+      d.structured_recommendation.tasks.forEach((t, i) => { text += `\n  ${i+1}. ${t.title}`; });
+    }
+    return { content: [{ type: 'text', text }] };
+  }
+);
+
+// Tool 26: Dispatch Instruction (Step 3 — multi-channel delivery + task list creation)
+server.registerTool(
+  'tascan_dispatch_instruction',
+  {
+    title: 'Dispatch Instruction',
+    description: 'Step 3 of the Closed-Loop. Multi-channel dispatch: issue thread, in-app message, progress feed, SMS, and optional remediation task list. Closes the loop from AI analysis to physical worker execution.',
+    inputSchema: {
+      issue_id: z.string().describe('Issue ID'),
+      instruction: z.string().describe('Actionable instruction for the worker'),
+      worker_id: z.string().optional().describe('Target worker ID (defaults to issue reporter)'),
+      remediation_tasks: z.array(z.any()).optional().describe('Tasks to create as remediation task list'),
+      recommendation_summary: z.string().optional().describe('Summary for task list description'),
+      send_sms: z.boolean().optional().describe('Send SMS (default: true if phone on file)'),
+      ai_agent: z.string().optional().describe('AI agent name (default: TaScan AI)')
+    },
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false
+    }
+  },
+  async ({ issue_id, instruction, worker_id, remediation_tasks, recommendation_summary, send_sms, ai_agent }) => {
+    const body = { instruction };
+    if (worker_id) body.worker_id = worker_id;
+    if (remediation_tasks) body.remediation_tasks = remediation_tasks;
+    if (recommendation_summary) body.recommendation_summary = recommendation_summary;
+    if (send_sms !== undefined) body.send_sms = send_sms;
+    if (ai_agent) body.ai_agent = ai_agent;
+    const result = await apiCall('POST', `/issues/${issue_id}/dispatch`, body);
+    const d = result.data;
+    let text = `Dispatched via ${d.channels.length} channels: ${d.channels.join(', ')}\n`;
+    text += `Worker: ${d.worker_id} | Issue: ${d.issue_id} (${d.issue_status})\n`;
+    text += `SMS: ${d.sms_status}\n`;
+    if (d.remediation_task_list_id) {
+      text += `Task List: ${d.remediation_task_list_id}\nWorker URL: ${d.worker_url}\nTasks: ${d.tasks_created}\n`;
+    }
+    text += `\nInstruction:\n${d.instruction}`;
+    return { content: [{ type: 'text', text }] };
+  }
+);
+
+// Tool 27: Auto-Resolve (Full Closed-Loop in one call — Patent Claim 7)
+server.registerTool(
+  'tascan_auto_resolve',
+  {
+    title: 'Auto-Resolve Issue',
+    description: 'FULL Closed-Loop Autonomous Operations Protocol in one call. Server-side AI analyzes issue, generates remediation tasks, creates task list, dispatches to worker via multi-channel delivery — all without human intervention. Patent Claim 7.',
+    inputSchema: {
+      issue_id: z.string().describe('Issue ID to auto-resolve')
+    },
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      openWorldHint: true
+    }
+  },
+  async ({ issue_id }) => {
+    const result = await apiCall('POST', `/issues/${issue_id}/auto-resolve`);
+    const d = result.data;
+    let text = `=== CLOSED-LOOP AUTONOMOUS OPERATIONS PROTOCOL ===\n`;
+    text += `Issue: ${d.issue_id}\n\n`;
+    text += `--- ANALYSIS ---\n`;
+    text += `Summary: ${d.analysis?.summary || 'N/A'}\n`;
+    text += `Classification: ${d.analysis?.classification?.type || 'N/A'} (${d.analysis?.classification?.severity || 'N/A'})\n`;
+    text += `Urgency: ${d.analysis?.urgency_score || 'N/A'}/10\n`;
+    if (d.analysis?.root_cause_hypotheses?.length) {
+      d.analysis.root_cause_hypotheses.forEach((h, i) => {
+        text += `  ${i+1}. ${h.hypothesis} (${Math.round(h.confidence * 100)}%)\n`;
+      });
+    }
+    text += `\n--- RECOMMENDATION ---\n`;
+    text += `Fix: ${d.recommendation?.recommendation_summary || 'N/A'}\n`;
+    text += `Tasks: ${d.recommendation?.tasks?.length || 0}\n`;
+    text += `Duration: ${d.recommendation?.estimated_duration_minutes || 'N/A'} min\n`;
+    text += `\n--- DISPATCH ---\n`;
+    text += `Channels: ${d.dispatch?.channels?.join(', ') || 'none'}\n`;
+    text += `SMS: ${d.dispatch?.sms_status || 'N/A'}\n`;
+    if (d.dispatch?.worker_url) text += `Worker URL: ${d.dispatch.worker_url}\n`;
+    if (d.dispatch?.remediation_task_list_id) text += `Task List: ${d.dispatch.remediation_task_list_id}\n`;
+    text += `\nTimestamps: analyzed ${d.timestamps?.analyzed_at} | recommended ${d.timestamps?.recommended_at} | dispatched ${d.timestamps?.dispatched_at}`;
+    return { content: [{ type: 'text', text }] };
+  }
+);
+
+
 // ─── Start Server ──────────────────────────────────────────
 async function main() {
   const transport = new StdioServerTransport();

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "tascan-mcp",
-  "version": "1.0.1",
+  "version": "2.1.0",
   "mcpName": "io.github.snowbikemike/tascan-mcp",
-  "description": "TaScan MCP Server — AI agent integration for the universal task protocol platform. Manage projects, events, tasks, workers, QR codes, templates, and reports. Scan. Task. Done.",
+  "description": "TaScan MCP Server — Closed-loop autonomous operations protocol. 27 tools for projects, tasks, workers, QR codes, AI issue analysis, and autonomous remediation dispatch. Patent pending. Scan. Task. Done.",
   "type": "module",
   "main": "index.js",
   "bin": {