securenow 8.17.0 → 8.19.0

package/mcp/catalog.js

@@ -353,7 +353,7 @@ const TOOLS = [
   {
     name: 'securenow_traces_show',
     title: 'Show Trace',
-    description: 'Show spans for a trace id scoped to one or more app keys.',
+    description: 'Show spans for a trace id scoped to one or more app keys. Fields identical on every span (service, environment and other resource attributes) come once under shared; empty fields are left out.',
     scope: 'traces:read',
     readOnly: true,
     method: 'GET',
@@ -385,6 +385,25 @@ const TOOLS = [
       limit: number('Maximum logs to return.', { minimum: 1, maximum: 500 }),
     }, ['appKeys']),
   },
+  {
+    name: 'securenow_logs_errors',
+    title: 'Summarize Error Logs',
+    description: 'What is failing: error (and fatal) log lines grouped by message, with ids, uuids, IPs and numbers normalized so repeats are one group. Each group: a sample line, how many times, first and last seen, environments, exception type and sample trace ids (pass one to securenow_logs_for_trace or securenow_traces_show). Far cheaper than listing raw logs. includeWarn adds warnings.',
+    scope: 'logs:read',
+    readOnly: true,
+    method: 'GET',
+    endpoint: '/logs/errors',
+    queryFields: ['appKeys', 'environment', 'since', 'from', 'to', 'includeWarn', 'limit'],
+    normalize: { appKeys: normalizeAppKeys },
+    inputSchema: objectSchema({
+      ...appKeysInput,
+      ...environmentInput,
+      since: string('Window: 30m, 1h (default), 6h, 2d; or pass from/to.'),
+      ...timeRangeInput,
+      includeWarn: boolean('Also group warnings.'),
+      limit: number('Maximum groups (default 20).', { minimum: 1, maximum: 100 }),
+    }, ['appKeys']),
+  },
   {
     name: 'securenow_logs_for_trace',
     title: 'Logs For Trace',
@@ -513,7 +532,7 @@ const TOOLS = [
       rootCauseKey: string('Optional root-cause group key to filter to one group.'),
       groupKey: string('Compatibility alias for rootCauseKey.'),
       includeRuns: boolean('Whether to include compact matching run rows in the response.'),
-      maxScan: number('Maximum pending-review rows to scan before grouping. Defaults to 500, capped at 1000.', { minimum: 1, maximum: 1000 }),
+      maxScan: number('Maximum pending-review rows to scan before grouping. Defaults to 1000 (the dashboard count), the maximum.', { minimum: 1, maximum: 1000 }),
     }),
   },
   {
@@ -728,7 +747,7 @@ const TOOLS = [
   {
     name: 'securenow_human_action_close_no_write',
     title: 'Close Human Action Without Enforcement',
-    description: 'Close one Requires Human IP row with an auditable no-write decision report. Use for ambiguous, skipped, rule-tuning-needed, new-rule-needed, rate-limited, or already-handled rows.',
+    description: 'Close one Requires Human IP row without blocking or marking it a false positive, with an auditable decision report (outcome: rate_limited, deferred, rule_tuning, new_alert_rule, ambiguous, skipped or other). This is how a "not now / not enforceable" decision leaves the queue; a decision report on its own does not.',
     scope: 'notifications:write',
     readOnly: false,
     confirm: true,
@@ -773,7 +792,7 @@ const TOOLS = [
   {
     name: 'securenow_human_case_action_update',
     title: 'Update Case-Level Human Action',
-    description: 'Approve, reject, execute, or fail a case-level proposed action such as tune_rule or create_exclusion. Write action; requires confirmation.',
+    description: 'Approve, reject, execute, or fail a case-level proposed action such as tune_rule or create_exclusion. Approving approve_block blocks the IPs and investigate_cluster starts investigations; approving tune_rule, create_exclusion or review_protected_ip only records the decision (apply the rule change first). Write action; requires confirmation.',
     scope: 'notifications:write',
     readOnly: false,
     confirm: true,
@@ -1381,13 +1400,13 @@ const TOOLS = [
   {
     name: 'securenow_alert_rule_draft',
     title: 'Draft an Alert Rule From English',
-    description: 'Turn a detection idea in plain English into an alert rule draft for one app, checked against that app\'s data. It reads the app\'s real event types, attribute keys and routes, then picks the kind: instant (conditions checked on every incoming request, alerts within seconds; one request is enough evidence) or periodic (SQL run on a schedule: counts, thresholds, distinct counts, ratios, sequences, baselines, security events, app log lines). Periodic SQL is run once against the data; instant conditions are replayed over the app\'s last 2000 requests, so check.matches shows what would alert today (false positives). Nothing is saved: create it with securenow_alert_rule_create, passing the draft fields. Waits up to 120 seconds.',
+    description: 'Turn a detection idea in plain English into an alert rule draft for one app, checked against that app\'s data. It reads the app\'s real event types, attribute keys and routes, then picks the kind: instant (conditions checked on every incoming request, alerts within seconds; one request is enough evidence) or periodic (SQL run on a schedule: counts, thresholds, distinct counts, ratios, sequences, baselines, security events, app log lines). Periodic SQL is run once against the data; instant conditions are replayed over the app\'s last 2000 requests, so check.matches shows what would alert today (false positives). Nothing is saved: create it with securenow_alert_rule_create, passing the draft fields. To CHANGE an existing rule, pass ruleId and describe the change in text: the draft is the whole rule rewritten (same kind, the rest kept), with `current` showing the rule as it is; apply it with securenow_alert_rule_update (sqlQuery + schedule, or instant {matchMode, conditions, environments}). Waits up to 120 seconds.',
     scope: 'alerts:write',
     readOnly: false,
     confirm: true,
     method: 'POST',
     endpoint: '/alert-rules/draft',
-    bodyFields: ['text', 'applicationKey', 'environment', 'kind'],
+    bodyFields: ['text', 'applicationKey', 'environment', 'kind', 'ruleId'],
     poll: {
       tool: 'securenow_alert_rule_draft_status',
       idField: 'draftId',
@@ -1400,8 +1419,9 @@ const TOOLS = [
       applicationKey: string('App key the rule watches; the draft is checked against its data.'),
       environment: string('Only watch this environment (e.g. production). Omit to watch every environment.'),
       kind: string('Optional: instant or periodic. Omit to let the drafter choose.'),
+      ruleId: string('Optional: an existing custom rule to change; text then describes the change. applicationKey defaults to one the rule watches.'),
       ...confirmSchema,
-    }, ['text', 'applicationKey', 'confirm', 'reason']),
+    }, ['text', 'confirm', 'reason']),
   },
   {
     name: 'securenow_alert_rule_draft_status',
@@ -1521,23 +1541,26 @@ const TOOLS = [
   {
     name: 'securenow_alert_rule_update',
     title: 'Update Alert Rule',
-    description: 'Update alert rule scope/status/schedule/throttle or record a review action. Write action; requires confirmation.',
+    description: 'Update alert rule scope/status/severity/schedule/throttle, a custom rule\'s SQL (sqlQuery, checked like create: scoped, time-bounded, with an ip column) or instant conditions (instant: {matchMode, conditions, environments}; omitted fields such as the instant block stay as they are), or record a review action. reviewNote is kept as the version\'s reason. Write action; requires confirmation.',
     scope: 'alerts:write',
     readOnly: false,
     confirm: true,
     method: 'PUT',
     endpoint: '/alert-rules/:id',
     pathParams: ['id'],
-    bodyFields: ['name', 'description', 'status', 'applicationsAll', 'applications', 'schedule', 'throttle', 'alertChannelIds', 'reviewAction', 'reviewNote', 'reviewNotificationId'],
+    bodyFields: ['name', 'description', 'severity', 'status', 'applicationsAll', 'applications', 'schedule', 'throttle', 'sqlQuery', 'instant', 'alertChannelIds', 'reviewAction', 'reviewNote', 'reviewNotificationId'],
     inputSchema: objectSchema({
       id: string('Alert rule id.'),
       name: string('Rule name for custom rules.'),
       description: string('Rule description for custom rules.'),
+      severity: string('critical, high, medium or low (custom rules).'),
       status: string('Active, Disabled, or Paused.'),
       applicationsAll: boolean('Scope rule to all applications.'),
       applications: arrayOfStrings('Application keys when applicationsAll is false.'),
       schedule: { type: 'object', additionalProperties: true, description: 'Schedule patch.' },
       throttle: { type: 'object', additionalProperties: true, description: 'Throttle patch {enabled, minutes}: one alert per address every N minutes.' },
+      sqlQuery: string('Custom periodic rules: the replacement detection SELECT (e.g. from a securenow_alert_rule_draft with ruleId).'),
+      instant: { type: 'object', additionalProperties: true, description: 'Custom instant rules: {matchMode, conditions: [{field, operator, value}], environments}. Fields left out keep their current values.' },
       alertChannelIds: arrayOfStrings('Alert channel ids.'),
       reviewAction: string('Rule review action: keep_active (keep it running and stop auto-pausing it) or tuned_version (the rule was tuned; resume it).'),
       reviewNote: string('Review note.'),
@@ -1928,6 +1951,37 @@ const TOOLS = [
       since: string('Window start: 30m, 1h (default), 2d or an ISO date; at most 7 days.'),
     }, ['id', 'ip']),
   },
+  {
+    name: 'securenow_alert_rule_request_promotion',
+    title: 'Ask a Person to Promote an Alert Rule',
+    description: 'Ask a person to promote a test-mode rule to prod, with why it is ready and the evidence (runs, notifications it caught, false-positive checks). Agents create rules in test mode and cannot approve this themselves: a person approves on the rules page or with `securenow human approve-promotion`, which moves the rule to prod (its instant block, matching automations and the AI pipeline can then act on its alerts). One pending request per rule. Write action; requires confirmation.',
+    scope: 'alerts:write',
+    readOnly: false,
+    confirm: true,
+    method: 'POST',
+    endpoint: '/alert-rules/:id/promotion-requests',
+    pathParams: ['id'],
+    bodyFields: ['reason', 'evidence'],
+    inputSchema: objectSchema({
+      id: string('Alert rule id (a custom rule in test mode).'),
+      evidence: string('What shows it is ready: e.g. runs and their outcomes, notifications it raised on real attacks, how many false positives in how long.'),
+      ...confirmSchema,
+    }, ['id', 'confirm', 'reason']),
+  },
+  {
+    name: 'securenow_alert_rule_promotion_requests',
+    title: 'List Alert Rule Promotion Requests',
+    description: 'Requests to promote test-mode rules to prod and their status (pending, approved, denied), who asked and why, and who decided.',
+    scope: 'alerts:read',
+    readOnly: true,
+    method: 'GET',
+    endpoint: '/alert-rules/promotion-requests',
+    queryFields: ['status', 'limit'],
+    inputSchema: objectSchema({
+      status: string('pending (default), approved, denied or all.'),
+      limit: number('How many (default 50, max 100).', { minimum: 1, maximum: 100 }),
+    }),
+  },
   {
     name: 'securenow_alert_rule_exclusions_list',
     title: 'List Alert Rule Exclusions',
@@ -2409,10 +2463,11 @@ const PROMPTS = [
   {
     name: 'soc_patrol',
     title: 'SOC Patrol (Scheduled)',
-    description: 'The recurring SOC pass SecureNow\'s built-in agent used to run on a 5-minute cron. Run it from your own harness (Claude, Hermes, OpenClaw, ...) on a schedule: Alert Review root-cause fixes first, then the Requires Human queue.',
+    description: 'One bounded pass over both review queues, meant to run on a schedule from your own agent (Claude Code, Codex, Cursor, ...): Alert Review rule fixes first, then the Requires Human queue.',
     arguments: [
       { name: 'maxAlertReviewGroups', description: 'Maximum alert-review root-cause groups to work this pass. Defaults to 10.', required: false },
       { name: 'maxHumanRows', description: 'Maximum Requires Human rows to work this pass. Defaults to 10.', required: false },
+      { name: 'search', description: 'Optional filter applied to both queues (an app name, rule, route or IP), e.g. to let a pass write only on one app.', required: false },
       { name: 'confirmWrites', description: 'Set true only when this scheduled run is allowed to execute decisions autonomously.', required: false },
     ],
   },
@@ -2541,7 +2596,8 @@ function promptMessages(name, args = {}) {
             `Review up to ${limit} row(s), most urgent first.${args.search ? ` Search filter: ${args.search}.` : ''}`,
             'Start with securenow_human_actions_list. For each row, call securenow_notifications_get and securenow_human_action_report, inspect the AI report/investigation steps/proofs/trace IDs, and fetch trace/log evidence where useful.',
             'For each row choose exactly one outcome: Block IP, Rate Limit, False Positive, Rule Tuning Applied/Needed, New Alert Rule Needed, Case Action Approved/Rejected, or Ambiguous/Skipped with exact missing proof.',
-            'Finished does not always mean enforcement changed. A row is also finished when a structured no-write decision report records the exact proof gap, missing permission, or vague guard and no weaker substitute write is used.',
+            'A row leaves the queue only when its status changes: a block, a false positive, an approved or rejected case action, or securenow_human_action_close_no_write (closes an IP row without enforcement, with an outcome and the exact proof gap, missing permission or vague guard). A decision report alone (securenow_human_action_decision_report_add) only adds a note: the row stays open.',
+            'Approving a tune_rule, create_exclusion or review_protected_ip case action records the decision and closes the row; it does not change the rule by itself. Apply the change first (rule tools), then approve. Reject a plan that is vague or wrong.',
             'If a global/system rule update is the right fix but access is denied, do not mark customer-specific false positives just to clear the row. Prepare the exact attack-preserving guard/SQL, dry-run it when possible, and record outcome=rule_tuning with missingProof.',
             'If evidence is mixed, do partial resolution: block proven malicious IPs, false-positive exact benign shapes, rate-limit route-specific volume abuse, and leave ambiguous IPs with their missing proof.',
             'Reject vague AI proposed actions. If the prompt/action lacks concrete rule id, path, method, status, user-agent/body/header guard, benign samples, and attack examples that still match, record it as ambiguous or rule_tuning needed.',
@@ -2549,9 +2605,9 @@ function promptMessages(name, args = {}) {
             'Do not rate-limit confirmed high-risk attacks that should be blocked, benign traffic that should be false-positive scoped, broad noisy rules that need tuning, app-server/proxy attribution problems, or isolated one-off requests.',
             'Do not create or recommend IP Allowlist entries while working this queue unless the user explicitly approves deny-by-default allowlist mode for the whole app/environment. Use Trusted IPs for trusted/bypass cases.',
             confirmWrites
-              ? 'The user requested execution. For supported decisions, call the correct write tool with confirm:true, a precise reason, and a decisionReport containing summary, evidence, reviewedHistory, traceIds, and missingProof when relevant, then continue. For skipped/ambiguous/rule-tuning-needed/new-rule-needed rows that should be auditable without changing enforcement status, use securenow_human_action_decision_report_add or securenow_human_case_decision_report_add.'
-              : 'Do not execute write tools yet. Produce a row-by-row action plan and exact MCP write calls for user approval.',
-            'For block decisions, use securenow_human_action_block. For rate-limit decisions, use securenow_rate_limit_create_from_text and then securenow_human_action_decision_report_add with outcome=rate_limited. For false positives, use securenow_human_action_false_positive with restrictive conditions. For case-level tune_rule/create_exclusion rows, inspect securenow_notifications_get and then use securenow_human_case_action_update only when the action is safe to approve/reject.',
+              ? 'The user requested execution. For supported decisions, call the correct write tool with confirm:true, a precise reason, and a decisionReport containing summary, evidence, reviewedHistory, traceIds, and missingProof when relevant, then continue. For IP rows you decide not to enforce (skipped, ambiguous, rule tuning needed, new rule needed, already rate-limited), close them with securenow_human_action_close_no_write and that outcome so they leave the queue.'
+              : 'Do not execute write tools yet. Read-only tools are fine, and so are the dry-run test tools (securenow_alert_rule_candidate_test, securenow_alert_rule_condition_candidate_test, securenow_alert_rule_condition_diff): they change nothing (pass confirm:true; they need an alerts:write key, so on a read-only key mark the guard untested). Produce a row-by-row action plan and exact MCP write calls for user approval.',
+            'For block decisions, use securenow_human_action_block. For rate-limit decisions, use securenow_rate_limit_create_from_text and then close the row with securenow_human_action_close_no_write outcome=rate_limited. For false positives, use securenow_human_action_false_positive with restrictive conditions. For case-level tune_rule/create_exclusion rows, inspect securenow_notifications_get and then use securenow_human_case_action_update: approve only after the change is applied, reject when the plan is vague or wrong.',
             'End with counts: handled, blocked/proposed block, rate limits created/proposed, false positives, rule tuning/admin permission blockers with exact guard, partial resolutions, skipped with missing proof, and still waiting.',
           ].join('\n'),
         },
@@ -2578,7 +2634,7 @@ function promptMessages(name, args = {}) {
             'After a rule fix, close the covered rows with securenow_alert_review_run_apply_group_decision (use previewOnly:true first; set allowMixed only after reviewing every row). For correct detections use securenow_alert_review_run_keep_alive. For one-off rows use securenow_alert_review_run_resolve or securenow_alert_review_run_dismiss with a full decision report.',
             confirmWrites
               ? 'The user requested execution. Call write tools with confirm:true, a precise reason, and a decisionReport containing summary, evidence, reviewedHistory, traceIds, and missingProof when relevant.'
-              : 'Do not execute write tools yet. Produce a group-by-group plan with the exact validated guards and MCP write calls for user approval.',
+              : 'Do not execute write tools yet. Read-only tools are fine, and so are the dry-run test tools (securenow_alert_rule_candidate_test, securenow_alert_rule_condition_candidate_test, securenow_alert_rule_condition_diff): they change nothing (pass confirm:true), so validate every guard you propose. They need an alerts:write key: on a read-only key, mark each guard untested instead. Produce a group-by-group plan with the exact validated guards and MCP write calls for user approval.',
             'Never resolve a group as false positive without concrete benign samples AND proof the guard preserves attack detection. When uncertain, keep the rule alive and leave the row open with the missing proof named.',
             'End with counts: groups worked, rules tuned (with the exact guards), rows resolved/dismissed/kept alive, rows left open with missing proof, and any permission blockers.',
           ].join('\n'),
@@ -2597,23 +2653,24 @@ function promptMessages(name, args = {}) {
         content: {
           type: 'text',
           text: [
-            'Run one scheduled SecureNow SOC patrol pass using the MCP tools. This is the recurring pass the built-in SecureNow agent used to run every 5 minutes; you are its external replacement, so be conservative, auditable, and finish in one bounded pass.',
+            'Run one scheduled SecureNow SOC patrol pass using the MCP tools. It works the two review queues: Alert Review ("is this rule right?": noisy or self-involving alert runs) and Requires Human ("what do we do about this IP or plan?": decisions SecureNow prepared but will not make alone). Be conservative and auditable, and finish in one bounded pass.',
             '',
             'Phase 0 — check for work:',
             '- Call securenow_alert_review_runs_count and securenow_human_actions_list (page=1, limit=1).',
             '- If both queues are empty, stop and report "no open SOC work".',
+            ...(args.search ? [`- Scope: only work rows and groups matching "${args.search}" (pass it as the search argument to the list tools); leave everything else for another pass.`] : []),
             '',
             'Phase 1 — Alert Review first (root-cause rule fixes are the upstream fix; they auto-resolve downstream human work):',
             `- Follow the work_alert_review runbook for up to ${maxAlertReviewGroups} root-cause group(s): list groups, inspect prototypes and siblings, validate narrow attack-preserving guards (two or more of path/method/status_code/user_agent) with condition tests/diffs before applying, tune rules, batch-resolve covered rows, keep real detections alive, and leave unclear rows open with the exact missing proof.`,
             '',
             'Phase 2 — Requires Human queue:',
-            `- Follow the work_human_actions runbook for up to ${maxHumanRows} row(s): list the queue most urgent first, read each AI report and trace evidence, then choose exactly one outcome per row (block, rate limit, scoped false positive, rule tuning, case action approve/reject, or an auditable no-write decision report with the missing proof).`,
+            `- Follow the work_human_actions runbook for up to ${maxHumanRows} row(s): list the queue most urgent first, read each AI report and trace evidence, then choose exactly one outcome per row (block, rate limit, scoped false positive, rule tuning, case action approve/reject, or close without enforcement via securenow_human_action_close_no_write with the missing proof). A decision report alone does not close a row.`,
             '- Re-check rows against any rule changes from Phase 1 before deciding — a Phase 1 fix often already covers them.',
             '',
             'Safety (this run may be unattended):',
             confirmWrites
               ? '- Writes are allowed this pass: call write tools with confirm:true, a precise reason, and a full decisionReport. Never block without high-confidence malicious evidence (riskScore >= 90 or equivalent proof). Never create broad false positives or single-condition exclusions. Prefer an auditable no-write decision report whenever evidence is mixed.'
-              : '- Read-only pass: do NOT call write tools. Produce the exact prepared write calls (with guards and reasons) as a reviewable plan.',
+              : '- Read-only pass: do NOT call write tools, except the dry-run test tools (securenow_alert_rule_candidate_test, securenow_alert_rule_condition_candidate_test, securenow_alert_rule_condition_diff), which change nothing (on a read-only key they are refused: mark those guards untested). Produce the exact prepared write calls (with guards and reasons) as a reviewable plan.',
             '- Never trust an IP globally, never create IP allowlist entries, never suppress on attacker-controllable fields alone.',
             '- Stay within the row/group budgets; leave the rest for the next scheduled pass.',
             '',
@@ -2704,8 +2761,40 @@ function mcpToolDefinition(tool) {
   };
 }
 
-function listTools() {
-  return TOOLS.map(mcpToolDefinition);
+// Tool profiles: a smaller tool list for an agent that does one job (fewer tools, less context).
+// Every profile keeps the auth and app tools. `securenow mcp --profile <name>` (or
+// SECURENOW_MCP_PROFILE) picks one; the default is every tool.
+const PROFILE_BASE_TOOLS = new Set(['securenow_auth_status', 'securenow_apps_list', 'securenow_apps_info']);
+const TOOL_PROFILES = {
+  investigator: {
+    description: 'Read-only investigation: notifications, traces, logs, IP intelligence, forensics questions and chat, rule run history and "why didn\'t this alert".',
+    includes: (tool) => tool.readOnly || /^securenow_forensics_(query|chat|chat_confirm)$/.test(tool.name),
+  },
+  detection: {
+    description: 'Write and tune detections: draft, create, test, run and explain alert rules, with the traces, logs, notifications and forensics to check them against.',
+    includes: (tool) => /^securenow_alert_rules?_/.test(tool.name)
+      || /^securenow_(traces|logs|forensics|ip)_/.test(tool.name)
+      || /^securenow_notifications_(list|get|batch_get)$/.test(tool.name),
+  },
+  responder: {
+    description: 'Respond to alerts: notifications, the human action queue and alert reviews, blocks, allowlist, trusted IPs, rate limits, challenges, automations, firewall and IP intelligence.',
+    includes: (tool) => /^securenow_(notifications|human|alert_review|blocklist|allowlist|trusted|rate_limit|challenge|automation|ip|firewall)_/.test(tool.name)
+      || ['securenow_alert_rule_get', 'securenow_alert_rule_runs', 'securenow_alert_rule_explain', 'securenow_traces_list', 'securenow_traces_show', 'securenow_logs_for_trace'].includes(tool.name),
+  },
+};
+
+function toolsForProfile(profile) {
+  const name = String(profile || 'all').trim().toLowerCase();
+  if (name === 'all') return TOOLS;
+  const selected = TOOL_PROFILES[name];
+  if (!selected) {
+    throw new Error(`Unknown MCP profile "${profile}". Use one of: all, ${Object.keys(TOOL_PROFILES).join(', ')}`);
+  }
+  return TOOLS.filter((tool) => PROFILE_BASE_TOOLS.has(tool.name) || selected.includes(tool));
+}
+
+function listTools(profile) {
+  return toolsForProfile(profile).map(mcpToolDefinition);
 }
 
 function listResources() {
@@ -2945,7 +3034,29 @@ function summarizeRateLimit(r) {
   return { ...r, metadata: undefined, effectiveStatus: r.status === 'active' && expired ? 'expired' : r.status };
 }
 
+// One trace's spans repeat the same resource fields (service, environment, SDK...) on every span:
+// keep those once under `shared` and drop empty fields, so a trace costs far less context.
+function compactSpans(res) {
+  if (!Array.isArray(res?.spans) || res.spans.length < 2) return res;
+  const spans = res.spans;
+  const isEmpty = (v) => v == null || v === '' || (typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length === 0)
+    || (Array.isArray(v) && v.length === 0);
+  const shared = {};
+  for (const key of new Set(spans.flatMap((span) => Object.keys(span || {})))) {
+    const first = JSON.stringify(spans[0]?.[key]);
+    if (spans.every((span) => JSON.stringify(span?.[key]) === first)) shared[key] = spans[0]?.[key];
+  }
+  const keep = (span) => Object.fromEntries(Object.entries(span || {}).filter(([key, value]) => !(key in shared) && !isEmpty(value)));
+  return {
+    ...res,
+    _compact: 'Fields identical on every span are listed once under shared; empty fields are left out.',
+    shared: Object.fromEntries(Object.entries(shared).filter(([, value]) => !isEmpty(value))),
+    spans: spans.map(keep),
+  };
+}
+
 const SUMMARIZERS = {
+  securenow_traces_show: compactSpans,
   securenow_notifications_list: (res) => (Array.isArray(res?.notifications) ? { ...res, notifications: res.notifications.map(summarizeNotification) } : res),
   securenow_alert_rules_list: (res) => {
     if (!Array.isArray(res?.alertRules)) return res;
@@ -3000,6 +3111,8 @@ module.exports = {
   getTool,
   mcpToolDefinition,
   listTools,
+  toolsForProfile,
+  TOOL_PROFILES,
   listResources,
   listPrompts,
   promptMessages,

package/mcp/server.js

@@ -9,6 +9,7 @@ const {
   RESOURCES,
   getTool,
   listTools,
+  toolsForProfile,
   listResources,
   listPrompts,
   promptMessages,
@@ -26,6 +27,17 @@ const {
 const SERVER_NAME = 'securenow';
 const PROTOCOL_VERSION = '2025-06-18';
 
+// `securenow mcp --profile investigator|detection|responder` (or SECURENOW_MCP_PROFILE) serves a
+// subset of the tools; the default is every tool.
+const PROFILE = String(process.env.SECURENOW_MCP_PROFILE || 'all').trim().toLowerCase() || 'all';
+let PROFILE_TOOL_NAMES;
+try {
+  PROFILE_TOOL_NAMES = new Set(toolsForProfile(PROFILE).map((tool) => tool.name));
+} catch (err) {
+  process.stderr.write(`[securenow mcp] ${err.message}\n`);
+  process.exit(2);
+}
+
 function write(message) {
   process.stdout.write(`${JSON.stringify(message)}\n`);
 }
@@ -201,7 +213,7 @@ function readResource(uri) {
 
   const text = resourceContent(resource, {
     projectConfig: () => jsonText(localAuthStatus()),
-    toolsCatalog: () => jsonText(listTools().map((tool) => ({
+    toolsCatalog: () => jsonText(listTools(PROFILE).map((tool) => ({
       name: tool.name,
       description: tool.description,
       readOnly: tool.annotations?.readOnlyHint === true,
@@ -240,7 +252,7 @@ async function handleRequest(message) {
     }
 
     if (method === 'ping') return ok(id, {});
-    if (method === 'tools/list') return ok(id, { tools: listTools() });
+    if (method === 'tools/list') return ok(id, { tools: listTools(PROFILE) });
     if (method === 'resources/list') return ok(id, { resources: listResources() });
     if (method === 'prompts/list') return ok(id, { prompts: listPrompts() });
 
@@ -262,6 +274,9 @@ async function handleRequest(message) {
       const args = params.arguments || {};
       const tool = getTool(name);
       if (!tool) throw new Error(`Unknown tool: ${name}`);
+      if (!PROFILE_TOOL_NAMES.has(name)) {
+        throw new Error(`Tool ${name} is not in the "${PROFILE}" MCP profile. Restart the server without --profile (or with another profile) to use it.`);
+      }
 
       const result = await callApiTool(tool, args);
       return ok(id, asToolResult({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securenow",
-  "version": "8.17.0",
+  "version": "8.19.0",
   "mcpName": "ai.securenow/securenow",
   "description": "OpenTelemetry instrumentation for Node.js, Next.js, and Nuxt - Send traces and logs to any OTLP-compatible backend",
   "type": "commonjs",
@@ -11,7 +11,7 @@
     "securenow-mcp": "mcp/server.js"
   },
   "scripts": {
-    "test": "node test-app-config.js && node test-resolve-ip.js && node test-otel-defaults.js && node test-telemetry.js && node test-legacy-semconv.js && node test-otp-redaction.js && node test-header-redaction.js && node test-firewall-paths.js && node test-rate-limits.js && node test-rate-limit-redis.js && node test-log-format.js && node test-crash-capture.js && node test-sdk-disabled.js && node test-internal-thread.js && node test-package-contents.js"
+    "test": "node test-app-config.js && node test-resolve-ip.js && node test-otel-defaults.js && node test-telemetry.js && node test-legacy-semconv.js && node test-otp-redaction.js && node test-header-redaction.js && node test-firewall-paths.js && node test-rate-limits.js && node test-rate-limit-redis.js && node test-log-format.js && node test-crash-capture.js && node test-sdk-disabled.js && node test-internal-thread.js && node test-esm-detect.js && node test-package-contents.js"
   },
   "keywords": [
     "opentelemetry",
@@ -160,6 +160,7 @@
     "challenge.js",
     "otel-defaults.js",
     "internal-thread.js",
+    "esm-detect.js",
     "legacy-semconv.js",
     "otp-redaction.js",
     "header-redaction.js",

package/register.js

@@ -14,13 +14,9 @@ if (require('./sdk-disabled').sdkDisabled('register')) return;
 // 1. Auto-register the ESM loader hook so customers never need --import
 (() => {
   try {
-    const fs = require('fs');
-    const path = require('path');
-    const pkgPath = path.resolve(process.cwd(), 'package.json');
-    if (!fs.existsSync(pkgPath)) return;
-
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8').replace(/^\uFEFF/, ''));
-    if (pkg.type !== 'module') return;
+    // ESM is decided by the entry script's package.json, not only the working directory's
+    // (process managers often start apps from another directory). See esm-detect.js.
+    if (!require('./esm-detect').detectEsmApp().esm) return;
 
     // Already registered via --import?
     const execArgv = process.execArgv.join(' ');

package/tracing.js

@@ -338,19 +338,13 @@ function collectMultipartMeta(request, contentType, sensitiveFields, maxTextFiel
 // (e.g. Node 18, or require('securenow/tracing') called directly without register.js).
 (() => {
   try {
-    const fs = require('fs');
-    const path = require('path');
-    const pkgPath = path.resolve(process.cwd(), 'package.json');
-    if (fs.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-      if (pkg.type === 'module') {
-        const execArgv = process.execArgv.join(' ');
-        const hasCliHook = execArgv.includes('hook.mjs') || execArgv.includes('import-in-the-middle');
-        const hasModuleRegister = typeof require('node:module').register === 'function';
-        if (!hasCliHook && !hasModuleRegister) {
-          console.warn('[securenow] ⚠️  ESM app detected ("type": "module") but no ESM loader hook available.');
-          console.warn('[securenow]    Upgrade to Node >=20.6 (recommended) or add: --import @opentelemetry/instrumentation/hook.mjs');
-        }
+    if (require('./esm-detect').detectEsmApp().esm) {
+      const execArgv = process.execArgv.join(' ');
+      const hasCliHook = execArgv.includes('hook.mjs') || execArgv.includes('import-in-the-middle');
+      const hasModuleRegister = typeof require('node:module').register === 'function';
+      if (!hasCliHook && !hasModuleRegister) {
+        console.warn('[securenow] ⚠️  ESM app detected ("type": "module") but no ESM loader hook available.');
+        console.warn('[securenow]    Upgrade to Node >=20.6 (recommended) or add: --import @opentelemetry/instrumentation/hook.mjs');
       }
     }
   } catch (_) {}