securenow 8.12.4 → 8.14.0

package/mcp/catalog.js

@@ -190,7 +190,7 @@ const TOOLS = [
   {
     name: 'securenow_auth_status',
     title: 'SecureNow Auth Status',
-    description: 'Show local SecureNow credential source, selected app, and masked runtime API key.',
+    description: 'Show who is signed in and how: over the hosted connector, the OAuth client, access level (investigate or investigate_and_respond) and the organization with the role of the person signed in; locally, the credential source, selected app and masked runtime API key.',
     scope: null,
     localOnly: true,
     readOnly: true,
@@ -209,7 +209,7 @@ const TOOLS = [
   {
     name: 'securenow_apps_create',
     title: 'Create Application',
-    description: 'Create a SecureNow application. Write action; requires confirmation. Each app is billed $99/month on subscribed accounts (free during the 14-day trial). Confirm with the user before creating apps.',
+    description: 'Create a SecureNow application. Write action; requires confirmation. Each app is billed $99/month on subscribed accounts (free during the 14-day trial). Creating one changes the bill.',
     scope: 'applications:write',
     readOnly: false,
     confirm: true,
@@ -318,16 +318,18 @@ const TOOLS = [
   {
     name: 'securenow_firewall_test_ip',
     title: 'Test Firewall IP Decision',
-    description: 'Check whether an IP would be blocked by the firewall.',
+    description: 'Check whether an IP would be blocked by the firewall. Pass path (and method) to evaluate route-scoped block rules the way the running app does, including case and trailing-slash aliases.',
     scope: 'firewall:read',
     readOnly: true,
     method: 'GET',
     endpoint: '/firewall/check/:ip',
     pathParams: ['ip'],
-    queryFields: ['environment', 'appKey'],
+    queryFields: ['environment', 'appKey', 'path', 'method'],
     inputSchema: objectSchema({
       ip: string('IPv4 address to test.'),
       appKey: string('Optional application key UUID to test the app/environment toggle and scoped lists.'),
+      path: string('Optional request path, for example /api/auth/login. Without it, route-scoped rules are not evaluated.'),
+      method: string('Optional HTTP method for the path, default GET.'),
       ...environmentInput,
     }, ['ip']),
   },
@@ -379,7 +381,7 @@ const TOOLS = [
       ...appKeysInput,
       ...environmentInput,
       ...timeRangeInput,
-      severity: string('Optional severity filter.'),
+      severity: string('Optional severity filter: debug, info, warn, error or fatal (case-insensitive). error also returns fatal crash records.'),
       limit: number('Maximum logs to return.', { minimum: 1, maximum: 500 }),
     }, ['appKeys']),
   },
@@ -403,13 +405,19 @@ const TOOLS = [
   {
     name: 'securenow_notifications_list',
     title: 'List Notifications',
-    description: 'List security notifications.',
+    description: 'List security alerts (notifications), newest first, as compact summaries: rule, severity, status, test mode, IPs with AI verdicts, agent status and proposed actions. Open alerts by default; securenow_notifications_get returns one alert in full.',
     scope: 'notifications:read',
     readOnly: true,
     method: 'GET',
     endpoint: '/notifications',
-    queryFields: ['limit', 'page'],
-    inputSchema: objectSchema({ ...pagingInput }),
+    queryFields: ['limit', 'page', 'status', 'severity', 'search', 'archived'],
+    inputSchema: objectSchema({
+      ...pagingInput,
+      status: string('Optional status filter, for example open, pending_review or resolved.'),
+      severity: string('Optional severity filter: critical, high, medium or low.'),
+      search: string('Optional text search over the alert title, IPs and rule.'),
+      archived: boolean('true lists archived alerts instead of open ones.'),
+    }),
   },
   {
     name: 'securenow_notifications_unread',
@@ -465,7 +473,7 @@ const TOOLS = [
   {
     name: 'securenow_human_actions_list',
     title: 'List Human Action Queue',
-    description: 'List approval-gated human decisions prepared by SecureNow AI, ordered by urgency.',
+    description: 'List approval-gated decisions prepared by SecureNow AI, most urgent first, as compact summaries: IP rows (kind ip) with the AI recommendation, risk score, confidence and proofs, and rule-level case actions (kind case_action, no IP) such as tune_rule.',
     scope: 'notifications:read',
     readOnly: true,
     method: 'GET',
@@ -609,7 +617,7 @@ const TOOLS = [
       prototypeRunId: string('Optional notification id whose root-cause key should be used.'),
       notificationIds: arrayOfStrings('Optional subset of eligible notification ids to close. Leave empty to apply to every eligible row in the group.'),
       status: string('Resolution status: resolved or dismissed. Defaults to resolved.'),
-      allowMixed: boolean('Allow a mixed decision/attribution group only after every row was manually reviewed. Defaults to false.'),
+      allowMixed: boolean('Allows a mixed decision/attribution group, meant for groups whose rows were all reviewed manually. Defaults to false.'),
       previewOnly: boolean('When true, returns the eligible rows without writing.'),
       maxRows: number('Maximum rows to close in this batch. Defaults to 100, capped at 250.', { minimum: 1, maximum: 250 }),
       maxScan: number('Maximum pending-review rows to scan before grouping. Defaults to 500, capped at 1000.', { minimum: 1, maximum: 1000 }),
@@ -635,7 +643,7 @@ const TOOLS = [
       prototypeRunId: string('Optional notification id whose root-cause key should be used.'),
       notificationIds: arrayOfStrings('Optional subset of eligible notification ids to close. Leave empty to apply to every eligible row in the group.'),
       status: string('Resolution status: resolved or dismissed. Defaults to resolved.'),
-      allowMixed: boolean('Allow a mixed decision/attribution group only after every row was manually reviewed. Defaults to false.'),
+      allowMixed: boolean('Allows a mixed decision/attribution group, meant for groups whose rows were all reviewed manually. Defaults to false.'),
       previewOnly: boolean('When true, returns the eligible rows without writing.'),
       maxRows: number('Maximum rows to close in this batch. Defaults to 100, capped at 250.', { minimum: 1, maximum: 250 }),
       maxScan: number('Maximum pending-review rows to scan before grouping. Defaults to 500, capped at 1000.', { minimum: 1, maximum: 1000 }),
@@ -751,7 +759,7 @@ const TOOLS = [
     inputSchema: objectSchema({
       notificationId: string('Notification id from the human action row.'),
       ip: string('IP address to mark as false positive.'),
-      conditions: { type: 'array', items: { type: 'object', additionalProperties: true }, description: 'Restrictive false-positive conditions. Prefer app/rule/path/method/status/user-agent/body scope.' },
+      conditions: { type: 'array', items: { type: 'object', additionalProperties: true }, description: 'Restrictive false-positive conditions, scoped by app, rule, path, method, status, user agent or body.' },
       matchMode: string('Condition match mode: all or any.'),
       createExclusion: boolean('Whether to create a restrictive exclusion rule.'),
       applyToExisting: boolean('Whether to apply to existing matching IP investigations.'),
@@ -818,30 +826,39 @@ const TOOLS = [
   {
     name: 'securenow_ip_traces',
     title: 'IP Traces',
-    description: 'Fetch traces associated with an IP address.',
+    description: 'Fetch the requests an IP made: time, app key, route, method, status code, duration and user agent, newest first. Covers the last 24 hours unless from/to are given, up to 500 requests per telemetry store, across every app unless appKeys are given; the response states the window.',
     scope: 'ip_intel:read',
     readOnly: true,
     method: 'GET',
     endpoint: '/ip/:ip/traces',
     pathParams: ['ip'],
-    queryFields: ['appKeys', 'environment'],
+    queryFields: ['appKeys', 'environment', 'from', 'to'],
     normalize: { appKeys: normalizeAppKeys },
     inputSchema: objectSchema({
       ip: string('IPv4 address.'),
       ...appKeysInput,
       ...environmentInput,
+      from: string('Start time as ISO 8601. Defaults to 24 hours before to.'),
+      to: string('End time as ISO 8601. Defaults to now.'),
     }, ['ip']),
   },
   {
     name: 'securenow_forensics_query',
     title: 'Run Forensics Query',
-    description: 'Run a natural-language forensic query. Write scope because it creates an async query job.',
+    description: 'Run a natural-language forensic query over your traffic and return the result rows. Waits up to 30 seconds; a query still running after that returns its jobId with status processing. Write scope because it creates an async query job.',
     scope: 'forensics:write',
     readOnly: false,
     confirm: true,
     method: 'POST',
     endpoint: '/forensics/query',
     bodyFields: ['query', 'applicationId', 'instanceId', 'environment'],
+    poll: {
+      tool: 'securenow_forensics_query_status',
+      idField: 'jobId',
+      pending: ['processing'],
+      timeoutMs: 30000,
+      intervalMs: 2000,
+    },
     inputSchema: objectSchema({
       query: string('Natural-language forensic query.'),
       applicationId: string('Optional application database id.'),
@@ -850,6 +867,19 @@ const TOOLS = [
       ...confirmSchema,
     }, ['query', 'confirm', 'reason']),
   },
+  {
+    name: 'securenow_forensics_query_status',
+    title: 'Forensics Query Result',
+    description: 'Get the status (processing, completed or failed), generated SQL and result rows of a forensics query job.',
+    scope: 'forensics:read',
+    readOnly: true,
+    method: 'GET',
+    endpoint: '/forensics/query/status/:jobId',
+    pathParams: ['jobId'],
+    inputSchema: objectSchema({
+      jobId: string('Forensics query job id.'),
+    }, ['jobId']),
+  },
   {
     name: 'securenow_forensics_library',
     title: 'Forensics Query Library',
@@ -1072,6 +1102,165 @@ const TOOLS = [
       ...confirmSchema,
     }, ['id', 'confirm', 'reason']),
   },
+  {
+    name: 'securenow_rate_limit_create',
+    title: 'Create Rate Limit',
+    description: 'Create a rate-limit rule from structured fields. The running app enforces it within about 10 seconds and answers 429 with Retry-After once the limit is reached. keyBy picks what each bucket counts: ip (default), global (one shared bucket), header (one bucket per value of keyName, e.g. x-api-key) or cookie (one bucket per value of keyName, e.g. session). Several rules can stack on one route (for example a burst limit and an hourly cap). Write action; requires confirmation.',
+    scope: 'rate_limits:write',
+    readOnly: false,
+    confirm: true,
+    method: 'POST',
+    endpoint: '/rate-limits',
+    bodyFields: ['name', 'appKey', 'environment', 'ip', 'pathPattern', 'pathMatchMode', 'method', 'keyBy', 'keyName', 'limit', 'windowSeconds', 'duration', 'expiresAt', 'status', 'reason'],
+    inputSchema: objectSchema({
+      name: string('Optional rule name.'),
+      appKey: string('Optional application key. Omit for all apps.'),
+      ip: string('Optional IPv4 address or CIDR the rule applies to. Omit for any IP.'),
+      pathPattern: string('Route pattern, for example /api/auth/login or /api/. A rule needs a route, an IP, or both.'),
+      pathMatchMode: { type: 'string', enum: ['exact', 'prefix', 'regex'], description: 'Path matching mode. Defaults to prefix.' },
+      method: { type: 'string', enum: ['ALL', 'GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'], description: 'HTTP method scope. Defaults to ALL.' },
+      keyBy: { type: 'string', enum: ['ip', 'global', 'header', 'cookie'], description: 'What each bucket counts. Defaults to ip.' },
+      keyName: string('Header or cookie name when keyBy is header or cookie, for example x-api-key or session.'),
+      limit: number('Requests allowed per window.', { minimum: 1, maximum: 1000000 }),
+      windowSeconds: number('Window length in seconds (1 to 86400).', { minimum: 1, maximum: 86400 }),
+      duration: string('Optional rule lifetime, for example 2h or 7d. Omit for no expiry.'),
+      expiresAt: string('Optional expiry time as ISO 8601 instead of duration.'),
+      status: { type: 'string', enum: ['active', 'disabled'], description: 'Create it disabled to stage it. Defaults to active.' },
+      ...environmentInput,
+      ...confirmSchema,
+    }, ['limit', 'windowSeconds', 'confirm', 'reason']),
+  },
+  {
+    name: 'securenow_rate_limit_update',
+    title: 'Update Rate Limit',
+    description: 'Change a rate-limit rule: enable or disable it (status), or change its limit, window, route, method, key or expiry. Only the fields you pass change. Write action; requires confirmation.',
+    scope: 'rate_limits:write',
+    readOnly: false,
+    confirm: true,
+    method: 'PUT',
+    endpoint: '/rate-limits/:id',
+    pathParams: ['id'],
+    bodyFields: ['name', 'status', 'limit', 'windowSeconds', 'pathPattern', 'pathMatchMode', 'method', 'keyBy', 'keyName', 'ip', 'duration', 'expiresAt', 'reason'],
+    inputSchema: objectSchema({
+      id: string('Rate-limit rule id.'),
+      name: string('Optional new name.'),
+      status: { type: 'string', enum: ['active', 'disabled'], description: 'active enables the rule, disabled stops enforcing it.' },
+      limit: number('New requests-per-window limit.', { minimum: 1, maximum: 1000000 }),
+      windowSeconds: number('New window length in seconds.', { minimum: 1, maximum: 86400 }),
+      pathPattern: string('New route pattern.'),
+      pathMatchMode: { type: 'string', enum: ['exact', 'prefix', 'regex'] },
+      method: { type: 'string', enum: ['ALL', 'GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'] },
+      keyBy: { type: 'string', enum: ['ip', 'global', 'header', 'cookie'] },
+      keyName: string('Header or cookie name for keyBy header/cookie.'),
+      ip: string('New IPv4 address or CIDR filter ("" for any IP).'),
+      duration: string('New lifetime from now, for example 2h.'),
+      expiresAt: string('New expiry as ISO 8601.'),
+      ...confirmSchema,
+    }, ['id', 'confirm', 'reason']),
+  },
+  {
+    name: 'securenow_firewall_hits',
+    title: 'Firewall Hits',
+    description: 'Who the firewall actually stopped: blocks (403), rate limits (429) and challenges, totalled per rule and per IP, plus the most recent hits. Use it to check that a new block or rate limit is working.',
+    scope: 'firewall:read',
+    readOnly: true,
+    method: 'GET',
+    endpoint: '/firewall/hits',
+    queryFields: ['appKey', 'environment', 'action', 'source', 'ruleId', 'ip', 'since', 'from', 'to', 'limit'],
+    inputSchema: objectSchema({
+      appKey: string('Optional application key.'),
+      action: { type: 'string', enum: ['blocked', 'rate_limited', 'captcha_challenged', 'captcha_passed', 'captcha_failed', 'allowed'], description: 'Optional action filter.' },
+      source: { type: 'string', enum: ['blocklist', 'allowlist', 'rate_limit', 'challenge'], description: 'Optional source filter.' },
+      ruleId: string('Optional rule id (rate limit, scoped block or challenge).'),
+      ip: string('Optional client IP.'),
+      since: string('Look-back window, for example 30m, 6h or 7d (default 24h, max 30d).'),
+      from: string('Optional start time as ISO 8601 (instead of since).'),
+      to: string('Optional end time as ISO 8601.'),
+      limit: number('Recent hits to return.', { minimum: 1, maximum: 200 }),
+      ...environmentInput,
+    }),
+  },
+  {
+    name: 'securenow_challenge_list',
+    title: 'List Challenges',
+    description: 'List proof-of-work challenge rules (an invisible check browsers pass and simple bots do not).',
+    scope: 'challenges:read',
+    readOnly: true,
+    method: 'GET',
+    endpoint: '/challenges',
+    queryFields: ['status', 'appKey', 'environment'],
+    inputSchema: objectSchema({
+      status: string('Optional status filter: active or disabled.'),
+      appKey: string('Optional application key.'),
+      ...environmentInput,
+    }),
+  },
+  {
+    name: 'securenow_challenge_create',
+    title: 'Create Challenge',
+    description: 'Serve a proof-of-work challenge on a route (optionally for one IP/CIDR and method). Browsers solve it invisibly and keep a clearance cookie; clients that cannot solve it never reach the route. Write action; requires confirmation.',
+    scope: 'challenges:write',
+    readOnly: false,
+    confirm: true,
+    method: 'POST',
+    endpoint: '/challenges',
+    bodyFields: ['name', 'appKey', 'environment', 'ip', 'pathPattern', 'pathMatchMode', 'method', 'difficulty', 'clearanceTtlSeconds', 'duration', 'status', 'reason'],
+    inputSchema: objectSchema({
+      name: string('Optional rule name.'),
+      appKey: string('Optional application key. Omit for all apps.'),
+      ip: string('Optional IPv4 address or CIDR. Omit for any IP.'),
+      pathPattern: string('Route pattern to protect, for example /api/signup.'),
+      pathMatchMode: { type: 'string', enum: ['exact', 'prefix', 'regex'] },
+      method: { type: 'string', enum: ['ALL', 'GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'] },
+      difficulty: number('Proof-of-work difficulty bits (4 to 28, default 14).', { minimum: 4, maximum: 28 }),
+      clearanceTtlSeconds: number('How long a solved challenge stays valid, in seconds (default 1800).', { minimum: 60 }),
+      duration: string('Optional rule lifetime, for example 24h.'),
+      status: { type: 'string', enum: ['active', 'disabled'] },
+      ...environmentInput,
+      ...confirmSchema,
+    }, ['confirm', 'reason']),
+  },
+  {
+    name: 'securenow_challenge_update',
+    title: 'Update Challenge',
+    description: 'Enable/disable a challenge rule or change its route, difficulty or expiry. Write action; requires confirmation.',
+    scope: 'challenges:write',
+    readOnly: false,
+    confirm: true,
+    method: 'PUT',
+    endpoint: '/challenges/:id',
+    pathParams: ['id'],
+    bodyFields: ['name', 'status', 'pathPattern', 'pathMatchMode', 'method', 'ip', 'difficulty', 'clearanceTtlSeconds', 'duration', 'reason'],
+    inputSchema: objectSchema({
+      id: string('Challenge rule id.'),
+      name: string('Optional new name.'),
+      status: { type: 'string', enum: ['active', 'disabled'] },
+      pathPattern: string('New route pattern.'),
+      pathMatchMode: { type: 'string', enum: ['exact', 'prefix', 'regex'] },
+      method: { type: 'string', enum: ['ALL', 'GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'] },
+      ip: string('New IPv4 address or CIDR filter.'),
+      difficulty: number('New difficulty bits.', { minimum: 4, maximum: 28 }),
+      clearanceTtlSeconds: number('New clearance lifetime in seconds.', { minimum: 60 }),
+      duration: string('New lifetime from now, for example 24h.'),
+      ...confirmSchema,
+    }, ['id', 'confirm', 'reason']),
+  },
+  {
+    name: 'securenow_challenge_remove',
+    title: 'Remove Challenge',
+    description: 'Remove a proof-of-work challenge rule. Write action; requires confirmation.',
+    scope: 'challenges:write',
+    readOnly: false,
+    confirm: true,
+    method: 'DELETE',
+    endpoint: '/challenges/:id',
+    pathParams: ['id'],
+    bodyFields: ['reason'],
+    inputSchema: objectSchema({
+      id: string('Challenge rule id.'),
+      ...confirmSchema,
+    }, ['id', 'confirm', 'reason']),
+  },
   {
     name: 'securenow_rate_limit_parse',
     title: 'Parse Rate Limit Text',
@@ -1105,12 +1294,18 @@ const TOOLS = [
   {
     name: 'securenow_alert_rules_list',
     title: 'List Alert Rules',
-    description: 'List alert rules, including system rules and app scope.',
+    description: 'List detection rules as compact summaries: name, mode (test or prod), status, severity, schedule, throttle, app scope and trigger stats. The detection SQL is left out; securenow_alert_rule_get returns one rule in full.',
     scope: 'alerts:read',
     readOnly: true,
     method: 'GET',
     endpoint: '/alert-rules',
-    inputSchema: objectSchema({}),
+    queryFields: ['status', 'mode', 'isSystem', 'active'],
+    inputSchema: objectSchema({
+      status: string('Optional status filter: Active, Disabled or Paused.'),
+      mode: string('Optional mode filter: test or prod.'),
+      isSystem: boolean('true lists only template rules, false only your own.'),
+      active: boolean('true lists only rules with status Active.'),
+    }),
   },
   {
     name: 'securenow_alert_rule_get',
@@ -1167,7 +1362,7 @@ const TOOLS = [
     bodyFields: ['version', 'reason'],
     inputSchema: objectSchema({
       id: string('Alert rule id (must be a custom, non-system rule).'),
-      version: number('Version number to restore. List options with securenow_alert_rule_versions.', { minimum: 1 }),
+      version: number('Version number to restore, as listed by securenow_alert_rule_versions.', { minimum: 1 }),
       ...confirmSchema,
     }, ['id', 'version', 'confirm', 'reason']),
   },
@@ -1257,7 +1452,7 @@ const TOOLS = [
     ],
     fixedBody: { auditSource: 'mcp' },
     inputSchema: objectSchema({
-      id: string('Alert rule id. Fetch with securenow_alert_rule_get first to get ruleVersion and instantHash.'),
+      id: string('Alert rule id.'),
       operations: {
         type: 'array',
         items: { type: 'object', additionalProperties: true },
@@ -1341,7 +1536,7 @@ const TOOLS = [
     ],
     fixedBody: { auditSource: 'mcp' },
     inputSchema: objectSchema({
-      id: string('Alert rule id. Fetch with securenow_alert_rule_conditions_get first to get ruleVersion and instantHash.'),
+      id: string('Alert rule id.'),
       operations: {
         type: 'array',
         items: { type: 'object', additionalProperties: true },
@@ -1400,7 +1595,7 @@ const TOOLS = [
     ],
     fixedBody: { auditSource: 'mcp', dryRun: true },
     inputSchema: objectSchema({
-      id: string('Alert rule id. Fetch with securenow_alert_rule_conditions_get first to get ruleVersion and instantHash.'),
+      id: string('Alert rule id.'),
       operations: {
         type: 'array',
         items: { type: 'object', additionalProperties: true },
@@ -1456,7 +1651,7 @@ const TOOLS = [
     ],
     fixedBody: { auditSource: 'mcp', dryRun: true },
     inputSchema: objectSchema({
-      id: string('Alert rule id. Fetch with securenow_alert_rule_conditions_get first to get ruleVersion and instantHash.'),
+      id: string('Alert rule id.'),
       operations: {
         type: 'array',
         items: { type: 'object', additionalProperties: true },
@@ -1692,11 +1887,12 @@ const TOOLS = [
     confirm: true,
     method: 'POST',
     endpoint: '/blocklist',
-    bodyFields: ['ip', 'reason', 'expiresAt', 'metadata', 'appKey', 'environment', 'pathPattern', 'pathMatchMode', 'method'],
+    bodyFields: ['ip', 'reason', 'expiresAt', 'duration', 'metadata', 'appKey', 'environment', 'pathPattern', 'pathMatchMode', 'method'],
     inputSchema: objectSchema({
       ip: string('IPv4 address or CIDR.'),
       reason: string('Reason for blocking.'),
       expiresAt: string('Optional expiry time as ISO 8601.'),
+      duration: string('Optional block lifetime instead of expiresAt, for example 15m, 2h or 7d.'),
       metadata: { type: 'object', additionalProperties: true, description: 'Optional metadata.' },
       appKey: string('Optional application key to scope this block. Omit for all apps.'),
       pathPattern: string('Optional route/path pattern, for example /admin*. Omit to block all routes.'),
@@ -1766,7 +1962,7 @@ const TOOLS = [
   {
     name: 'securenow_allowlist_add',
     title: 'Add Restrictive Allowlist IP',
-    description: 'Dangerous production action: add an IP/CIDR to the restrictive allowlist. Once active, allowlist mode blocks every IP except listed entries. Do not use this to mark an IP trusted or suppress false positives; use securenow_trusted_add instead. Requires explicit human approval confirming deny-all behavior.',
+    description: 'Dangerous production action: add an IP/CIDR to the restrictive allowlist. Once active, allowlist mode blocks every IP except listed entries, so it is not a way to mark an IP trusted or suppress false positives (trusted IPs are a separate list). The server rejects the call unless allowlistDenyAllApproved is true.',
     scope: 'allowlist:write',
     readOnly: false,
     confirm: true,
@@ -1781,7 +1977,7 @@ const TOOLS = [
       expiresAt: string('Optional expiry time as ISO 8601.'),
       applicationsAll: boolean('Apply to all applications.'),
       applicationKeys: arrayOfStrings('Application keys to scope this allowlist entry to.'),
-      allowlistDenyAllApproved: boolean('Must be true only after the user explicitly approves deny-by-default allowlist behavior. Do not set this for trusted IPs, monitors, false positives, or investigation cleanup.'),
+      allowlistDenyAllApproved: boolean('Confirms the deny-by-default behavior: once the allowlist has entries, every unlisted IP is blocked. Must be true.'),
       ...environmentInput,
       ...confirmSchema,
     }, ['ip', 'confirm', 'reason', 'allowlistDenyAllApproved']),
@@ -1871,6 +2067,11 @@ const DESTRUCTIVE_TOOLS = new Set([
   'securenow_automation_rule_delete',
   'securenow_rate_limit_remove',
   'securenow_rate_limit_create_from_text',
+  'securenow_rate_limit_create',
+  'securenow_rate_limit_update',
+  'securenow_challenge_create',
+  'securenow_challenge_update',
+  'securenow_challenge_remove',
   'securenow_alert_rule_rollback',
   'securenow_alert_rule_update',
   'securenow_alert_rule_query_update',
@@ -2294,6 +2495,8 @@ function mcpToolDefinition(tool) {
     description: tool.description,
     inputSchema: tool.inputSchema || objectSchema({}),
     annotations: {
+      // Directory listings (Claude's connector review) read the title here too.
+      title: tool.title,
       readOnlyHint: !!tool.readOnly,
       destructiveHint: !tool.readOnly && !!tool.destructive,
       idempotentHint: !!tool.readOnly,
@@ -2372,6 +2575,209 @@ function buildApiRequest(tool, rawArgs = {}) {
   };
 }
 
+// Async tools (tool.poll) return a job id; follow it with the status tool until
+// the job settles or the wait runs out. fetchStatus(request) performs one API call.
+async function pollToolResult(tool, first, fetchStatus) {
+  const spec = tool.poll;
+  const id = spec && first && first[spec.idField];
+  if (!id || !spec.pending.includes(first.status)) return first;
+  const statusTool = getTool(spec.tool);
+  const deadline = Date.now() + spec.timeoutMs;
+  let last = first;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, spec.intervalMs));
+    last = await fetchStatus(buildApiRequest(statusTool, { [spec.idField]: id }));
+    if (!last || !spec.pending.includes(last.status)) return last;
+  }
+  if (last && last.error) {
+    return { ...last, message: `Not finished after ${Math.round(spec.timeoutMs / 1000)} seconds, and the last attempt failed: ${last.error}. It may be retrying; ${statusTool.name} with ${spec.idField} ${id} shows its state. A narrower question (one app, a shorter window) usually avoids this.` };
+  }
+  return { ...last, message: `Still running. Call ${statusTool.name} with ${spec.idField} ${id} to get the result.` };
+}
+
+// Tool results land in a chat context, so very large API responses (a 500-IP
+// investigation, every saved rule) are shrunk: long arrays keep their first
+// items and long strings are cut, with a note saying how to narrow the call.
+const MAX_RESULT_CHARS = 60000;
+const TRIM_STEPS = [[50, 4000], [20, 2000], [10, 1000], [5, 400], [3, 200], [1, 100]];
+const TRUNCATED_NOTE = 'This result was shortened to fit the conversation. Use filters, a smaller limit or a get tool for the full details.';
+
+function trimValue(value, maxItems, maxString) {
+  if (typeof value === 'string') {
+    return value.length > maxString ? `${value.slice(0, maxString)}… [${value.length - maxString} more characters]` : value;
+  }
+  if (Array.isArray(value)) {
+    const kept = value.slice(0, maxItems).map((item) => trimValue(item, maxItems, maxString));
+    if (value.length > maxItems) kept.push(`… ${value.length - maxItems} more items not shown`);
+    return kept;
+  }
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) out[key] = trimValue(item, maxItems, maxString);
+    return out;
+  }
+  return value;
+}
+
+// Tool results are sent as compact JSON, so sizes are measured that way.
+const compactJson = (value) => JSON.stringify(value);
+
+function fitToolResult(value, maxChars = MAX_RESULT_CHARS) {
+  if (value == null || typeof value !== 'object') return value;
+  if (compactJson(value).length <= maxChars) return value;
+  for (const [maxItems, maxString] of TRIM_STEPS) {
+    const trimmed = trimValue(value, maxItems, maxString);
+    const wrapped = Array.isArray(trimmed) ? { _truncated: TRUNCATED_NOTE, result: trimmed } : { _truncated: TRUNCATED_NOTE, ...trimmed };
+    if (compactJson(wrapped).length <= maxChars) return wrapped;
+  }
+  return { _truncated: TRUNCATED_NOTE, preview: compactJson(value).slice(0, maxChars) };
+}
+
+// List tools return compact rows so a page of results fits in a chat context;
+// the matching get tools return one record in full. Each summarizer keeps the
+// response envelope (pagination, summary) and only reshapes the rows.
+const clip = (value, max = 300) => (typeof value === 'string' && value.length > max ? `${value.slice(0, max)}…` : value);
+const firstN = (list, n) => (Array.isArray(list) ? list.slice(0, n) : []);
+
+function summarizeNotification(n) {
+  const investigations = Array.isArray(n.ipInvestigations) ? n.ipInvestigations : [];
+  return {
+    id: n._id || n.id,
+    title: n.title,
+    detectionName: n.alertContext?.detectionName || null,
+    alertRuleId: n.alertRuleId,
+    severity: n.severity,
+    status: n.status,
+    testMode: n.testMode === true,
+    applications: n.applications,
+    occurrences: n.occurrences,
+    firstOccurredAt: n.firstOccurredAt,
+    lastOccurredAt: n.lastOccurredAt,
+    createdAt: n.createdAt,
+    readAt: n.readAt || null,
+    primaryIp: n.primaryIp || null,
+    ipCount: Math.max(n.ipSummary?.totalCount || 0, investigations.length, (n.relatedIps || []).length + (n.primaryIp ? 1 : 0)),
+    stormSignal: n.ipSummary?.stormSignal === true,
+    resultCount: n.resultCount,
+    agent: n.agentState ? { status: n.agentState.status, summary: clip(n.agentState.summary, 200), confidence: n.agentState.confidence } : null,
+    proposedActions: firstN(n.proposedActions, 3).map((a) => ({
+      actionKey: a.actionKey, type: a.type, status: a.status, confidence: a.confidence, ips: firstN(a.scope?.ips, 5),
+    })),
+    ips: firstN(investigations, 5).map((i) => ({ ip: i.ip, status: i.status, riskScore: i.riskScore, hitCount: i.hitCount })),
+  };
+}
+
+function summarizeRule(r) {
+  return {
+    id: r.id || r._id,
+    name: r.name,
+    detection: clip(r.queryMappingId?.nlpQuery || r.description, 140) || null,
+    mode: r.mode,
+    status: r.status,
+    severity: r.severity,
+    isSystem: r.isSystem === true,
+    executionMode: r.executionMode,
+    applicationsAll: r.applicationsAll,
+    applications: r.applications,
+    schedule: r.schedule?.enabled === false ? null : r.schedule?.cronExpression || null,
+    throttleMinutes: r.throttle?.enabled === false ? 0 : r.throttle?.minutes ?? null,
+    instant: r.instant ? { enabled: r.instant.enabled === true, block: r.instant.block === true } : null,
+    exclusions: Array.isArray(r.exclusions) ? r.exclusions.length : 0,
+    stats: r.stats ? {
+      triggerCount: r.stats.triggerCount, executionCount: r.stats.executionCount,
+      lastTriggeredAt: r.stats.lastTriggeredAt || null, lastExecutedAt: r.stats.lastExecutedAt || null,
+    } : null,
+    currentVersion: r.currentVersion,
+  };
+}
+
+function summarizeTask(t) {
+  const proofs = t.proofs || {};
+  return {
+    id: t.id,
+    kind: t.kind || 'ip',
+    actionKey: t.actionKey,
+    actionType: t.actionType,
+    notificationId: t.notificationId,
+    ip: t.ip,
+    alertRuleId: t.alertRuleId,
+    title: t.title,
+    detectionName: t.detectionName,
+    severity: t.severity,
+    applications: t.applications,
+    hitCount: t.hitCount,
+    firstSeenAt: t.firstSeenAt,
+    lastSeenAt: t.lastSeenAt,
+    urgencyScore: t.urgencyScore,
+    cluster: t.cluster ? { clusterId: t.cluster.clusterId, label: t.cluster.label, ipCount: t.cluster.ipCount, riskScore: t.cluster.riskScore } : null,
+    aiDecision: t.aiDecision ? {
+      recommendation: t.aiDecision.recommendation, label: t.aiDecision.label, riskScore: t.aiDecision.riskScore,
+      confidence: t.aiDecision.confidence, completedAt: t.aiDecision.completedAt, reason: clip(t.aiDecision.reason || t.aiDecision.summary, 300),
+    } : null,
+    proofs: {
+      paths: firstN(proofs.paths, 5), methods: firstN(proofs.methods, 5), statusCodes: firstN(proofs.statusCodes, 5),
+      userAgents: firstN(proofs.userAgents, 3).map((ua) => clip(ua, 120)), traceIds: firstN(proofs.traceIds, 5),
+      rootCauseKey: proofs.rootCauseKey, evidenceShape: proofs.evidenceShape,
+    },
+  };
+}
+
+function summarizeApp(a) {
+  return {
+    id: a._id || a.id,
+    key: a.key,
+    name: a.name,
+    status: a.status,
+    hosts: a.hosts,
+    firewallEnabled: a.firewallEnabled,
+    tracingEnabled: a.tracingEnabled,
+    loggingEnabled: a.loggingEnabled,
+    lastTelemetryAt: a.lastTelemetryAt || null,
+    lastTelemetryEnvironment: a.lastTelemetryEnvironment || null,
+    lastTraceAt: a.lastTraceAt || null,
+    lastTraceEnvironment: a.lastTraceEnvironment || null,
+    lastLogAt: a.lastLogAt || null,
+    lastLogEnvironment: a.lastLogEnvironment || null,
+  };
+}
+
+function summarizeRateLimit(r) {
+  const expired = !!r.expiresAt && new Date(r.expiresAt).getTime() < Date.now();
+  return { ...r, metadata: undefined, effectiveStatus: r.status === 'active' && expired ? 'expired' : r.status };
+}
+
+const SUMMARIZERS = {
+  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;
+    const rules = res.alertRules;
+    const count = (fn) => rules.filter(fn).length;
+    const counts = {
+      total: rules.length,
+      active: count((r) => r.status === 'Active'),
+      prodActive: count((r) => r.status === 'Active' && r.mode === 'prod'),
+      testActive: count((r) => r.status === 'Active' && r.mode === 'test'),
+      paused: count((r) => r.status === 'Paused'),
+      disabled: count((r) => r.status === 'Disabled'),
+      neverTriggered: count((r) => !r.stats?.triggerCount),
+    };
+    return { counts, ...res, alertRules: rules.map(summarizeRule) };
+  },
+  securenow_human_actions_list: (res) => (Array.isArray(res?.tasks) ? { ...res, tasks: res.tasks.map(summarizeTask) } : res),
+  securenow_apps_list: (res) => (Array.isArray(res?.applications) ? { ...res, applications: res.applications.map(summarizeApp) } : res),
+  securenow_rate_limit_list: (res) => (Array.isArray(res?.rateLimits) ? { ...res, rateLimits: res.rateLimits.map(summarizeRateLimit) } : res),
+};
+
+function summarizeToolResult(tool, result) {
+  const summarize = tool && SUMMARIZERS[tool.name];
+  if (!summarize || result == null || typeof result !== 'object') return result;
+  try {
+    return summarize(result);
+  } catch (_) {
+    return result;
+  }
+}
+
 function readStaticResource(resource) {
   const filepath = path.resolve(__dirname, resource.file);
   return fs.readFileSync(filepath, 'utf8');
@@ -2400,6 +2806,9 @@ module.exports = {
   promptMessages,
   assertConfirmed,
   buildApiRequest,
+  pollToolResult,
+  fitToolResult,
+  summarizeToolResult,
   resourceContent,
   jsonText,
   maskSecret,