tascan-mcp 3.2.0 → 3.4.0

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "tascan-mcp",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "mcpName": "io.github.snowbikemike/tascan-mcp",
-  "description": "TaScan MCP Server — Closed-loop autonomous operations protocol. 43 tools for projects, tasks, workers, QR codes, NFC tags, geofenced zones, AI condition assessment, worker passports, AI issue analysis, and autonomous remediation dispatch. 14 patents filed (435+ claims). Task. Scan. Done.",
+  "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",
   "main": "index.js",
   "bin": {

package/tools.cjs

@@ -560,7 +560,8 @@ const TOOLS = [
         text += '\n';
         if (args.include_responses && task.responses && task.responses.length > 0) {
           for (const resp of task.responses) {
-            const { value, note } = fmtResponse(resp.response_value, resp.notes);
+            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;
             text += `    -> ${value != null ? value : '(no value)'}${note ? ' — ' + note : ''} (${resp.worker_name}, ${resp.completed_at})\n`;
           }
         }
@@ -588,7 +589,8 @@ const TOOLS = [
       const r = result.data;
       let text = `Responses for "${r.task}" in project "${r.project_name}" (${r.matched_tasks} matching task(s), ${r.responses.length} response(s), oldest first):\n\n`;
       for (const resp of r.responses) {
-        const { value, note } = fmtResponse(resp.response_value, resp.notes);
+        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)'}`;
         if (note) text += ` — ${note}`;
@@ -1015,7 +1017,7 @@ const TOOLS = [
     inputSchema: {
       type: 'object',
       properties: {
-        asset_id: { type: 'string', description: 'Asset ID from tascan_register_asset / tascan_list_assets' },
+        asset_id: { type: 'string', description: 'Asset ID (from tascan_register_asset or tascan_list_assets)' },
         photo_url: { type: 'string', description: 'Public URL of the assessment photo' },
         worker_name: { type: 'string', description: 'Who took the photo (optional)' }
       },
@@ -1068,6 +1070,74 @@ const TOOLS = [
     }
   },
 
+  {
+    name: 'tascan_list_assets',
+    description: 'List registered condition-ledger assets with their latest condition scores. Use to recover an asset_id for tascan_assess_condition or tascan_condition_history.',
+    inputSchema: {
+      type: 'object',
+      properties: { project_id: { type: 'string', description: 'Filter by project' } },
+      required: []
+    },
+    annotations: { title: 'List Condition Assets', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: async (args, api) => {
+      const path = '/assets' + (args.project_id ? `?project_id=${args.project_id}` : '');
+      const result = await api('GET', path);
+      const assets = result.data || [];
+      if (!assets.length) return 'No assets registered. Use tascan_register_asset to add one.';
+      return assets.map(a =>
+        `${a.name} (${a.id})${a.serial_number ? '\n  SN: ' + a.serial_number : ''}${a.asset_type ? ' · ' + a.asset_type : ''}${a.location_description ? '\n  Location: ' + a.location_description : ''}`
+      ).join('\n\n');
+    }
+  },
+
+  // ─── Gig Payments (verification-gated direct payer→worker) ───────
+  {
+    name: 'tascan_request_payment',
+    description: 'Pledge a payment on a task list: when the list is verified complete (every task done + photo evidence on photo-required tasks), the payer automatically receives a Stripe pay link that routes the money DIRECTLY to the worker (0% TaScan fee). No money moves and no card is stored at pledge time. The worker must have completed payout onboarding (Get Paid on their profile).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        task_list_id: { type: 'string', description: 'Task list the payment is tied to' },
+        worker_id: { type: 'string', description: 'Worker who gets paid' },
+        amount_cents: { type: 'number', description: 'Amount in cents ($1 min, $10,000 max)' },
+        payer_email: { type: 'string', description: 'Who pays — receives the pay link on verification' },
+        payer_name: { type: 'string' },
+        memo: { type: 'string', description: 'What the payment is for (shown to the payer)' }
+      },
+      required: ['task_list_id', 'worker_id', 'amount_cents', 'payer_email']
+    },
+    annotations: { title: 'Request Verified Payment', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    handler: async (args, api) => {
+      const result = await api('POST', '/payments', args);
+      const p = result.data;
+      return `Payment pledged: $${(p.amount_cents / 100).toFixed(2)} to worker ${p.worker_id}\n\nID: ${p.id}\nStatus: ${p.status}\nPayer: ${p.payer_email}\n\n${result.note || 'Pay link is issued automatically when the list is verified complete.'}`;
+    }
+  },
+  {
+    name: 'tascan_list_payments',
+    description: 'List gig payments and their lifecycle status: awaiting_completion (pledged, work not verified yet), ready_to_pay (verified — pay link sent to payer), paid, canceled. Filter by task list or status.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        task_list_id: { type: 'string', description: 'Filter by task list' },
+        status: { type: 'string', enum: ['awaiting_completion', 'ready_to_pay', 'paid', 'canceled'], description: 'Filter by status' }
+      },
+      required: []
+    },
+    annotations: { title: 'List Gig Payments', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: async (args, api) => {
+      const qs = [];
+      if (args.task_list_id) qs.push(`task_list_id=${args.task_list_id}`);
+      if (args.status) qs.push(`status=${args.status}`);
+      const result = await api('GET', '/payments' + (qs.length ? '?' + qs.join('&') : ''));
+      const payments = result.data || [];
+      if (!payments.length) return 'No payments found.';
+      return payments.map(p =>
+        `$${(p.amount_cents / 100).toFixed(2)} — ${p.status.toUpperCase()}\n  ID: ${p.id}\n  List: ${p.task_list_id}\n  Payer: ${p.payer_email}${p.memo ? '\n  Memo: ' + p.memo : ''}${p.paid_at ? '\n  Paid: ' + p.paid_at : p.released_at ? '\n  Link issued: ' + p.released_at : ''}`
+      ).join('\n\n');
+    }
+  },
+
   // ─── Worker Passport (Patent 4 foundation) ───────────────────────
   {
     name: 'tascan_get_worker_passport',
@@ -1088,6 +1158,91 @@ const TOOLS = [
         `Member since: ${(s.member_since || '').slice(0, 10)}\n\n` +
         `Badges: ${p.badges.length ? p.badges.join(' · ') : 'none yet'}\n\nShareable profile: ${p.profile_url}`;
     }
+  },
+
+  // ─── Read-layer integrity (from the 2026-08-18 MCP audit) ────────
+  {
+    name: 'tascan_server_info',
+    description: 'Identify exactly which TaScan server and schema this MCP session is talking to. Call this FIRST when diagnosing anything — it makes "dev server masquerading as production" and "is my fix deployed yet" one tool call instead of an inference.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    annotations: { title: 'Server Info', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: async (args, api) => {
+      let pkgVersion = 'unknown';
+      try { pkgVersion = require('./package.json').version; } catch (e) {}
+      let meta = null;
+      try { meta = (await api('GET', '/meta')).data; } catch (e) { meta = { error: String(e.message || e) }; }
+      return `TaScan MCP Server Info\n\n` +
+        `tascan-mcp package: v${pkgVersion} (${TOOLS.length} tools)\n` +
+        `API service: ${meta?.service || 'UNREACHABLE'}\n` +
+        `Host: ${meta?.host || '?'} · Environment: ${meta?.environment || '?'}\n` +
+        `Org: ${meta?.org_id || '?'}\n` +
+        `DB schema: ${meta?.schema_version || '?'}\n` +
+        `Server time: ${meta?.server_time || '?'}` +
+        (meta?.error ? `\nAPI error: ${meta.error}` : '');
+    }
+  },
+  {
+    name: 'tascan_find',
+    description: 'Cross-entity search: find projects, task lists, tasks, workers, or condition assets by name in one call — with ids and parent context to disambiguate. Use this instead of walking projects→lists→tasks or guessing ids from display names.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search text (min 2 chars, case-insensitive substring)' },
+        type: { type: 'string', enum: ['project', 'list', 'task', 'worker', 'asset'], description: 'Optional: restrict to one entity type' }
+      },
+      required: ['query']
+    },
+    annotations: { title: 'Find Anything', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: async (args, api) => {
+      let path = `/find?q=${encodeURIComponent(args.query)}`;
+      if (args.type) path += `&type=${args.type}`;
+      const result = await api('GET', path);
+      const rows = result.data || [];
+      if (!rows.length) return `No matches for "${args.query}".`;
+      return rows.map(r => `[${r.type}] ${r.name}\n  id: ${r.id}${r.parent_id ? '\n  parent: ' + r.parent_id : ''}${r.context ? '\n  ' + r.context : ''}`).join('\n\n');
+    }
+  },
+  {
+    name: 'tascan_get_worker',
+    description: 'Ungated, plain read of one worker row: name, contact, org, points, streaks, timestamps. (tascan_get_worker_passport is the rich stats view; this is the boring lookup.)',
+    inputSchema: {
+      type: 'object',
+      properties: { worker_id: { type: 'string', description: 'Worker ID' } },
+      required: ['worker_id']
+    },
+    annotations: { title: 'Get Worker', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: async (args, api) => {
+      const result = await api('GET', `/workers/${args.worker_id}`);
+      return JSON.stringify(result.data, null, 2);
+    }
+  },
+  {
+    name: 'tascan_find_duplicate_workers',
+    description: 'Find candidate same-person worker records with per-signal match detail (Patent 4 §6.25(b) signals: phone reuse, name similarity, GPS pattern correlation). Turns identity fragmentation from an accidental discovery into a monitorable metric, and feeds the merge workflow its candidate list.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        worker_id: { type: 'string', description: 'Anchor worker to find duplicates OF (preferred — enables phone + GPS signals)' },
+        name: { type: 'string', description: 'Or: search duplicates by display name' },
+        threshold: { type: 'number', description: 'Min confidence 0-1 (default 0.15)' }
+      },
+      required: []
+    },
+    annotations: { title: 'Find Duplicate Workers', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: async (args, api) => {
+      const qs = [];
+      if (args.worker_id) qs.push(`worker_id=${args.worker_id}`);
+      if (args.name) qs.push(`name=${encodeURIComponent(args.name)}`);
+      if (args.threshold != null) qs.push(`threshold=${args.threshold}`);
+      const result = await api('GET', '/workers/duplicates?' + qs.join('&'));
+      const d = result.data;
+      if (!d.candidates.length) return `No duplicate candidates for ${d.anchor.name || d.anchor.id}.`;
+      let text = `Duplicate candidates for ${d.anchor.name || ''} (${d.anchor.id || 'name search'}):\n`;
+      d.candidates.forEach(c => {
+        text += `\n${c.name} (${c.id}) — confidence ${c.confidence}\n  signals: ${JSON.stringify(c.signals)}\n  created ${String(c.created_at).slice(0, 10)} · last active ${String(c.last_active_at || '').slice(0, 10)} · ${c.total_points} pts`;
+      });
+      return text;
+    }
   }
 ];