tascan-mcp 3.5.0 → 3.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tascan-mcp",
-  "version": "3.5.0",
+  "version": "3.7.0",
   "mcpName": "io.github.snowbikemike/tascan-mcp",
   "description": "TaScan MCP Server — Closed-loop autonomous operations protocol. 50 tools for projects, tasks, workers, QR codes, NFC tags, geofenced zones, AI condition assessment, worker passports, verification-gated gig payments, cross-entity search, duplicate-worker detection, AI issue analysis, and autonomous remediation dispatch. 14 patents filed (435+ claims). Task. Scan. Done.",
   "type": "module",

package/tools.cjs

@@ -252,8 +252,25 @@ const TOOLS = [
               title: { type: 'string', description: 'Task title' },
               description: { type: 'string', description: 'Task description' },
               response_type: { type: 'string', enum: ['checkbox', 'photo', 'text', 'number', 'date', 'choice'], description: 'CRITICAL: "text" for names, phones, emails, notes, addresses, any free-form input. "photo" for tasks needing photographic proof (inspections, serial numbers, packed cases). "checkbox" ONLY for simple yes/no confirmations. "number" for numeric values. "date" for dates. "choice" for multiple-choice (needs response_config.options). Most info-collection tasks should be "text", most verification tasks should be "photo".' },
+              response_config: { type: 'object', description: 'Response configuration. For "choice": {options: ["A","B","C"]}. For "text": {placeholder, multiline}. For "number": {placeholder}. For "date": {label, include_text}.' },
               is_safety_checkpoint: { type: 'boolean', description: 'Safety-critical task flag' },
-              requires_photo: { type: 'boolean', description: 'Require photo on completion' }
+              requires_photo: { type: 'boolean', description: 'Require photo on completion' },
+              sort_order: { type: 'number', description: 'Explicit sort position (defaults to end of list, in array order)' },
+              required_equipment: { type: 'string', description: 'Equipment this task depends on (free text, e.g. "88 lb kettlebells")' },
+              subtasks: {
+                type: 'array',
+                items: {
+                  type: 'object',
+                  properties: {
+                    title: { type: 'string', description: 'Subtask title (e.g. "Set 1")' },
+                    response_type: { type: 'string', enum: ['checkbox', 'number', 'text', 'choice'], description: 'Typed subtask response. "number" for per-set values (reps/weight), "text" for notes, "choice" needs response_config.options. Default checkbox.' },
+                    response_config: { type: 'object', description: 'Same shape as task response_config' },
+                    requires_photo: { type: 'boolean' }
+                  },
+                  required: ['title']
+                },
+                description: 'Subtasks created with the task. Example set logging: [{title:"Set 1",response_type:"number"},{title:"Set 2",response_type:"number"},{title:"Set 3",response_type:"number"}]'
+              }
             },
             required: ['title']
           },
@@ -386,9 +403,11 @@ const TOOLS = [
         title: { type: 'string', description: 'New title' },
         description: { type: 'string', description: 'New description' },
         response_type: { type: 'string', enum: ['checkbox', 'photo', 'text', 'number', 'date', 'choice'], description: 'See tascan_add_tasks for guidance. "text" for info collection, "photo" for visual proof, "checkbox" for yes/no only.' },
+        response_config: { type: 'object', description: 'Response configuration. For "choice": {options: [...]}. See tascan_add_tasks.' },
         is_safety_checkpoint: { type: 'boolean', description: 'Safety-critical flag' },
         requires_photo: { type: 'boolean', description: 'Require photo' },
-        sort_order: { type: 'number', description: 'Sort position' }
+        sort_order: { type: 'number', description: 'Sort position' },
+        required_equipment: { type: 'string', description: 'Equipment this task depends on (free text)' }
       },
       required: ['task_id']
     },
@@ -400,6 +419,157 @@ const TOOLS = [
       return `Task updated: ${result.data.title}\n\n${JSON.stringify(result.data, null, 2)}`;
     }
   },
+  {
+    name: 'tascan_reply_with_list',
+    description: 'Reply to a task list WITH a task list — the two-way tasking primitive. Creates a new list linked into the parent\'s thread, aimed back at whoever sent the original (e.g. "Grant access — pick a window" with response_type date, or an info request with response_type text). The org gets pinged; the thread shows in both the worker portal and Simple Mode. Use tascan_get_thread-style follow-up via tascan_list_projects/tascan_get_report to read answers.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        parent_list_id: { type: 'string', description: 'The list being replied to' },
+        title: { type: 'string', description: 'Reply list title (e.g. "Before I can start...")' },
+        author_name: { type: 'string', description: 'Who is replying (shown in the thread)' },
+        tasks: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              title: { type: 'string' },
+              description: { type: 'string' },
+              response_type: { type: 'string', enum: ['checkbox', 'text', 'number', 'date', 'choice', 'photo'], description: '"date" for scheduling windows, "text" for info requests, "choice" needs response_config.options' },
+              response_config: { type: 'object' }
+            },
+            required: ['title']
+          },
+          description: 'Items the recipient answers — each becomes a typed task'
+        }
+      },
+      required: ['parent_list_id', 'title', 'tasks']
+    },
+    annotations: { title: 'Reply With a List', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    handler: async (args) => {
+      const resp = await fetch('https://app.tascan.io/.netlify/functions/list-reply', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          parent_list_id: args.parent_list_id,
+          title: args.title,
+          author_name: args.author_name,
+          tasks: args.tasks
+        })
+      });
+      const data = await resp.json();
+      if (!resp.ok) throw new Error(data.error || 'Reply failed');
+      return `Reply list created and linked into the thread!\n  List: ${args.title} (${data.list_id})\n  Thread: ${data.thread_id}\n  Tasks: ${data.task_count}\n  Worker link: ${data.worker_url}\nThe org has been pinged via app_messages.`;
+    }
+  },
+  {
+    name: 'tascan_add_subtasks',
+    description: 'Add one or more subtasks to a task (bulk). Subtasks support typed responses: "number" for per-set data (reps, weight, distance), "text" for notes, "choice" for options, "checkbox" for simple steps. Set-logging example: task "Bench Press" with subtasks Set 1/Set 2/Set 3 each response_type "number" — each completed set stores its value and timestamp, giving per-set timing for progression tracking.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        task_id: { type: 'string', description: 'Parent task ID' },
+        subtasks: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              title: { type: 'string', description: 'Subtask title (e.g. "Set 1")' },
+              description: { type: 'string', description: 'Optional detail' },
+              response_type: { type: 'string', enum: ['checkbox', 'number', 'text', 'choice'], description: 'Default checkbox. "number" for per-set values. "choice" needs response_config.options.' },
+              response_config: { type: 'object', description: 'For "choice": {options: [...]}. For "number"/"text": {placeholder}.' },
+              requires_photo: { type: 'boolean', description: 'Require photo on completion' },
+              sort_order: { type: 'number', description: 'Explicit position (defaults to end, in array order)' }
+            },
+            required: ['title']
+          },
+          description: 'Array of subtasks to create'
+        }
+      },
+      required: ['task_id', 'subtasks']
+    },
+    annotations: { title: 'Add Subtasks', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    handler: async (args, api) => {
+      const result = await api('POST', `/tasks/${args.task_id}/subtasks`, args.subtasks);
+      return `${result.count} subtask(s) created on task ${args.task_id}\n\n${JSON.stringify(result.data, null, 2)}`;
+    }
+  },
+  {
+    name: 'tascan_list_subtasks',
+    description: 'List the subtasks of a task, including completion state, stored response values, and completion timestamps (per-set timing).',
+    inputSchema: {
+      type: 'object',
+      properties: { task_id: { type: 'string', description: 'Parent task ID' } },
+      required: ['task_id']
+    },
+    annotations: { title: 'List Subtasks', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: async (args, api) => {
+      const result = await api('GET', `/tasks/${args.task_id}/subtasks`);
+      return JSON.stringify(result.data, null, 2);
+    }
+  },
+  {
+    name: 'tascan_update_subtask',
+    description: 'Update a subtask (title, description, response_type, response_config, requires_photo, sort_order).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        subtask_id: { type: 'string', description: 'Subtask ID' },
+        title: { type: 'string' },
+        description: { type: 'string' },
+        response_type: { type: 'string', enum: ['checkbox', 'number', 'text', 'choice'] },
+        response_config: { type: 'object' },
+        requires_photo: { type: 'boolean' },
+        sort_order: { type: 'number' }
+      },
+      required: ['subtask_id']
+    },
+    annotations: { title: 'Update Subtask', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: async (args, api) => {
+      const { subtask_id, ...updates } = args;
+      const body = Object.fromEntries(Object.entries(updates).filter(([, v]) => v !== undefined));
+      const result = await api('PUT', `/subtasks/${subtask_id}`, body);
+      return `Subtask updated: ${result.data.title}\n\n${JSON.stringify(result.data, null, 2)}`;
+    }
+  },
+  {
+    name: 'tascan_complete_subtask',
+    description: 'Complete a subtask, optionally recording a typed response_value (e.g. the weight or reps for that set). Each completion is timestamped, so consecutive set completions yield per-set durations. Returns progress including all_subtasks_complete — when true, complete the parent task with tascan_complete_task.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        subtask_id: { type: 'string', description: 'Subtask ID to complete' },
+        worker_id: { type: 'string', description: 'Worker performing the completion (optional)' },
+        response_value: { type: 'string', description: 'Typed response value (for number/text/choice subtasks), e.g. "165"' },
+        notes: { type: 'string', description: 'Optional notes' }
+      },
+      required: ['subtask_id']
+    },
+    annotations: { title: 'Complete Subtask', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    handler: async (args, api) => {
+      const result = await api('POST', `/subtasks/${args.subtask_id}/complete`, {
+        worker_id: args.worker_id,
+        response_value: args.response_value,
+        notes: args.notes
+      });
+      const d = result.data;
+      return `Subtask completed!\n  ${d.subtask_title}${d.response_value ? ' = ' + d.response_value : ''}\n  Task: ${d.task_title}\n  Progress: ${d.subtasks_done}/${d.subtasks_total}${d.all_subtasks_complete ? '\n  ALL SUBTASKS COMPLETE — parent task is ready to complete.' : ''}`;
+    }
+  },
+  {
+    name: 'tascan_delete_subtask',
+    description: 'Delete a subtask and its completions. This action is irreversible.',
+    inputSchema: {
+      type: 'object',
+      properties: { subtask_id: { type: 'string', description: 'Subtask ID to delete' } },
+      required: ['subtask_id']
+    },
+    annotations: { title: 'Delete Subtask', readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    handler: async (args, api) => {
+      await api('DELETE', `/subtasks/${args.subtask_id}`);
+      return `Subtask ${args.subtask_id} deleted successfully.`;
+    }
+  },
   {
     name: 'tascan_delete_task',
     description: 'Delete a specific task and its completions. This action is irreversible.',
@@ -571,7 +741,7 @@ const TOOLS = [
   },
   {
     name: 'tascan_query_responses',
-    description: "Query one task's submitted responses across every list in a project — e.g. the same exercise repeated across many workout lists returns one chronological progression series instead of N report lookups. Match by task title pattern or exact task ID.",
+    description: "Query one task's submitted responses across every list in a project — e.g. the same exercise repeated across many workout lists returns one chronological progression series instead of N report lookups. Match by task title pattern or exact task ID. Subtask completions interleave into the same series labeled 'Task › Subtask' (e.g. per-set values Set 1/2/3 with their own timestamps), so set-level progression chains across lists automatically.",
     inputSchema: {
       type: 'object',
       properties: {
@@ -592,7 +762,8 @@ const TOOLS = [
         const { value: v0, note } = fmtResponse(resp.response_value, resp.notes);
         const value = (v0 == null && resp.photo_url) ? '[photo submitted]' : (v0 != null && resp.photo_url) ? v0 + ' [+photo]' : v0;
         const when = (resp.completed_at || '').slice(0, 16).replace('T', ' ');
-        text += `${when} · ${resp.list_name} · ${resp.task_title}: ${value != null ? value : '(no value)'}`;
+        const label = resp.subtask_title ? `${resp.task_title} › ${resp.subtask_title}` : resp.task_title;
+        text += `${when} · ${resp.list_name} · ${label}: ${value != null ? value : '(no value)'}`;
         if (note) text += ` — ${note}`;
         text += ` (${resp.worker_name})\n`;
       }
@@ -896,31 +1067,97 @@ const TOOLS = [
   },
   {
     name: 'tascan_get_scan_history',
-    description: 'Get scan event history for a registered NFC tag — timestamps, GPS coordinates, and accuracy for each scan',
+    description: 'Scan accountability data. Two modes: (1) tag_id — scans of a registered NFC tag; (2) task_list_id or project_id — every QR/link page-open stamp: when the code was scanned, GPS + IP + channel (qr/nfc/sms/email/link), who the scanner turned out to be, and the scan→start delta (how long between scanning and actually identifying + starting work — the sign-in-and-vanish metric).',
     inputSchema: {
       type: 'object',
       properties: {
-        tag_id: { type: 'string', description: 'Tag registry ID (from tascan_list_tags)' },
-        limit: { type: 'number', description: 'Max results (default 50)' }
+        tag_id: { type: 'string', description: 'NFC tag registry ID (from tascan_list_tags) — tag mode' },
+        task_list_id: { type: 'string', description: 'Task list ID — page-scan mode' },
+        project_id: { type: 'string', description: 'Project ID — page-scan mode, all lists in the project' },
+        source: { type: 'string', description: 'Filter page scans by channel: qr | nfc | sms | email | link | unknown' },
+        since: { type: 'string', description: 'ISO timestamp — only scans after this' },
+        limit: { type: 'number', description: 'Max results (default 50, max 200)' }
       },
-      required: ['tag_id']
+      required: []
     },
     annotations: { title: 'Get Scan History', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     handler: async (args, api) => {
-      const path = `/tags/${args.tag_id}/scans` + (args.limit ? `?limit=${args.limit}` : '');
-      const result = await api('GET', path);
-      const scans = result.data;
-      if (!scans.length) return 'No scans recorded for this tag.';
-      let text = `${scans.length} scan(s):\n\n`;
+      if (args.tag_id) {
+        const path = `/tags/${args.tag_id}/scans` + (args.limit ? `?limit=${args.limit}` : '');
+        const result = await api('GET', path);
+        const scans = result.data;
+        if (!scans.length) return 'No scans recorded for this tag.';
+        let text = `${scans.length} tag scan(s):\n\n`;
+        scans.forEach((s, i) => {
+          text += `${i + 1}. ${s.scanned_at}`;
+          if (s.gps_lat && s.gps_lng) text += ` — GPS: ${s.gps_lat.toFixed(6)}, ${s.gps_lng.toFixed(6)} (±${Math.round(s.gps_accuracy || 0)}m)`;
+          text += '\n';
+        });
+        return text;
+      }
+      if (!args.task_list_id && !args.project_id) {
+        return 'Provide tag_id (NFC tag mode) or task_list_id / project_id (page-scan mode).';
+      }
+      const qs = new URLSearchParams();
+      if (args.task_list_id) qs.set('task_list_id', args.task_list_id);
+      else qs.set('project_id', args.project_id);
+      if (args.source) qs.set('source', args.source);
+      if (args.since) qs.set('since', args.since);
+      if (args.limit) qs.set('limit', String(args.limit));
+      const result = await api('GET', '/scans?' + qs.toString());
+      const scans = result.data || [];
+      if (!scans.length) return 'No page scans recorded yet for this scope.';
+      const converted = scans.filter(s => s.converted);
+      const deltas = converted.map(s => s.scan_to_start_secs).filter(n => n != null);
+      const median = deltas.length ? deltas.sort((a, b) => a - b)[Math.floor(deltas.length / 2)] : null;
+      let text = `${scans.length} scan(s) — ${converted.length} converted to a working session (${Math.round(converted.length / scans.length * 100)}%)`;
+      if (median != null) text += ` · median scan→start ${median}s`;
+      text += '\n\n';
       scans.forEach((s, i) => {
-        text += `${i + 1}. ${s.scanned_at}`;
-        if (s.gps_lat && s.gps_lng) text += ` — GPS: ${s.gps_lat.toFixed(6)}, ${s.gps_lng.toFixed(6)} (±${Math.round(s.gps_accuracy || 0)}m)`;
+        text += `${i + 1}. ${s.scanned_at} · ${s.scan_source || 'unknown'}`;
+        if (s.worker_name) text += ` · ${s.worker_name}`;
+        text += s.converted ? ` · started +${s.scan_to_start_secs}s` : ' · NEVER STARTED';
+        if (s.ip) text += ` · ip ${s.ip}`;
+        if (s.gps_lat && s.gps_lng) text += ` · GPS ${s.gps_lat.toFixed(5)}, ${s.gps_lng.toFixed(5)}`;
         text += '\n';
       });
       return text;
     }
   },
 
+  // ─── Worker Marketplace (Patent 4: portable reputation) ──────────
+  {
+    name: 'tascan_search_marketplace',
+    description: 'Search the cross-org Worker Marketplace: workers who opted in (discoverable=true on their passport), ranked by passkey trust tier + verified completion volume.  Skills are AI-inferred from REAL completed work, not resumes — each carries a verified_task_count and a civilian_equivalent job title.  Returns sanitized public cards only (first name + last initial, skills, stats, passport URL) — never phone, email, or org membership.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        q: { type: 'string', description: 'Skill, category, name, or civilian job title — e.g. "forklift", "LED wall", "AV technician"' },
+        min_completions: { type: 'number', description: 'Only workers with at least this many verified completions' },
+        limit: { type: 'number', description: 'Max cards (default 25, max 50)' }
+      },
+      required: []
+    },
+    annotations: { title: 'Search Worker Marketplace', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: async (args, api) => {
+      const qs = new URLSearchParams();
+      if (args.q) qs.set('q', args.q);
+      if (args.min_completions) qs.set('min_completions', String(args.min_completions));
+      if (args.limit) qs.set('limit', String(args.limit));
+      const result = await api('GET', '/marketplace' + (qs.toString() ? '?' + qs.toString() : ''));
+      const cards = result.data || [];
+      if (!cards.length) return 'No discoverable workers match.  Workers appear after opting in on their own passport (profile page → "List me").';
+      return cards.map(w => {
+        let t = `${w.name}${w.passkey_verified ? ' ✓ID-VERIFIED' : ''} — ${w.completions} verified completions · ${w.points} pts · since ${w.member_since}`;
+        if (w.skills.length) t += '\n  Skills: ' + w.skills.map(s => `${s.skill} (${s.verified_task_count}×)`).join(', ');
+        const civ = [...new Set(w.skills.map(s => s.civilian_equivalent).filter(Boolean))];
+        if (civ.length) t += '\n  Civilian equivalent: ' + civ.join(' · ');
+        t += '\n  Passport: ' + w.passport_url;
+        return t;
+      }).join('\n\n');
+    }
+  },
+
   // ─── Geofenced Zones (Patent 7: location-triggered delivery) ─────
   {
     name: 'tascan_create_zone',
@@ -940,6 +1177,7 @@ const TOOLS = [
         auto_clock_in: { type: 'boolean', description: 'Entering the zone writes a shift_start clock-in event' },
         auto_clock_out: { type: 'boolean', description: 'Leaving the zone writes a shift_end clock-out event' },
         notify_email: { type: 'string', description: 'Alert recipient override — defaults to all org admins' },
+        polygon: { type: 'array', items: { type: 'array', items: { type: 'number' } }, description: 'Polygon/rectangle zone instead of a circle: vertices as [[lat,lng], ...], at least 3.  lat/lng/radius_m are then computed (centroid + bounding radius) — still pass lat/lng but they are overridden.' },
         description: { type: 'string', description: 'Shown to workers on the Site Gate page' }
       },
       required: ['name', 'lat', 'lng']
@@ -984,7 +1222,8 @@ const TOOLS = [
         enforce_on_list: { type: 'boolean' }, is_active: { type: 'boolean' },
         notify_on_enter: { type: 'boolean' }, notify_on_exit: { type: 'boolean' },
         auto_clock_in: { type: 'boolean' }, auto_clock_out: { type: 'boolean' },
-        notify_email: { type: 'string' }
+        notify_email: { type: 'string' },
+        polygon: { type: 'array', items: { type: 'array', items: { type: 'number' } }, description: 'Replace geometry with a polygon ([[lat,lng],...], ≥3 vertices); pass null to revert to a circle' }
       },
       required: ['zone_id']
     },