securenow 8.18.0 → 8.19.0

package/README.md

@@ -174,8 +174,11 @@ Everything the MCP server can do is also a command. Run `npx securenow help` for
 
 | Command | Description |
 |---|---|
-| `securenow human list` / `human show <row>` | Review AI-prepared decisions awaiting a human |
+| `securenow review` / `review show <row>` | Alert Review: rules that fired too wide and paused themselves |
+| `securenow review group <row> --outcome rule_tuning --reason "..." --yes` | Close every run of a group after fixing its rule |
+| `securenow human list` / `human show <row>` | Requires Human: AI-prepared decisions awaiting a human |
 | `securenow human block <row> --yes --reason "..."` | Approve a proposed block |
+| `securenow human close <row> --outcome deferred --reason "..." --yes` | Close a row without blocking |
 | `securenow blocklist add <ip> [--route /admin*] [--mode prefix] [--duration 24h] [--reason "..."]` | Block an IP globally or per-route |
 | `securenow blocklist unblock <id> --reason "..."` | Stop enforcement, keep the history |
 | `securenow ratelimit from-text "5 per minute per IP on POST /api/login for 2h" --yes` | Rate-limit rule from natural language |

package/SKILL-CLI.md

@@ -244,7 +244,41 @@ securenow notifications read-all             # mark all as read
 securenow notifications unread               # unread count
 ```
 
-### Human Actions — AI-Prepared Decision Queue
+### Two review queues
+
+SecureNow decides most things alone (instant blocks, automations, IP investigations, self-pausing
+rules). What it won't decide alone waits in two queues. Work **Alert Review** first: one rule fix
+closes every run it caused and the Requires Human rows that came from the same noise.
+
+| Queue | Question | Decisions | CLI |
+|---|---|---|---|
+| Alert Review | "Is this rule right?" A rule fired far too wide, or on an IP treated as your own infrastructure; it usually pauses itself | tune the rule, keep it on, close/dismiss with a reason (never blocks or unblocks) | `securenow review` |
+| Requires Human | "What do we do about this IP or plan?" An investigated IP with a verdict SecureNow won't act on alone, or a proposed plan | block, false positive, close without blocking, approve/reject a plan | `securenow human` |
+
+### Alert Review — is this rule right?
+
+```bash
+securenow review                             # open runs grouped by root cause (rule + route + evidence shape)
+securenow review list --search lab-auth      # one app (name or key), rule, route or IP
+securenow review show 1                      # group 1: rule, route, IPs, proposed guard, its runs
+securenow review show <notificationId>       # one run
+securenow review keep <notificationId> --reason "Correct detection" --yes     # turn the rule back on, stop it auto-pausing, close the run
+securenow review close <notificationId> --outcome rule_tuning --reason "..." --yes
+securenow review dismiss <notificationId> --reason "Not worth acting on" --yes
+securenow review group 1 --outcome rule_tuning --reason "Guard added in v4" --preview   # what would close
+securenow review group 1 --outcome rule_tuning --reason "Guard added in v4" --yes       # close the whole group
+```
+
+Outcomes: `rule_tuning`, `false_positive`, `clean`, `deferred`, `new_alert_rule`, `rate_limited`,
+`ambiguous`, `skipped`, `other`. Closing writes a decision report on the alert and changes no
+enforcement. Tune the rule first (`securenow alerts rules change <id> "..."`), then close its group.
+A mixed group (rows disagree on verdict or sender) needs `--allow-mixed` after reviewing every row.
+
+MCP parity: `securenow_alert_review_runs_list`, `securenow_alert_review_run_get`,
+`securenow_alert_review_run_keep_alive`, `securenow_alert_review_run_resolve`,
+`securenow_alert_review_run_dismiss`, `securenow_alert_review_run_apply_group_decision`; prompt `work_alert_review`.
+
+### Requires Human — what do we do about this IP or plan?
 
 Use this for the same work shown in **Requires Human**: AI has already grouped alerts, fetched traces, built a report, and left a final Block IP or False Positive decision.
 
@@ -254,6 +288,7 @@ securenow human list --limit 20
 securenow human show 1                       # inspect row 1 with AI report, investigation steps, proofs, trace links
 securenow human block 1 --yes --reason "AI evidence confirmed malicious"
 securenow human fp 1 --yes --reason "Scoped false positive after evidence review"
+securenow human close 1 --outcome deferred --reason "Scanner, nothing reachable; not worth a block" --yes   # leaves the queue, nothing blocked
 securenow human action 1 --status rejected --yes --reason "Tuning guard is too broad"
 securenow human prompt 1                     # print a Codex/Claude MCP prompt for this row
 securenow human work --limit 10              # list queue + print MCP runbook for deep queue work
@@ -266,9 +301,26 @@ MCP parity:
 - `securenow_human_action_report`
 - `securenow_human_action_block`
 - `securenow_human_action_false_positive`
+- `securenow_human_action_close_no_write`
 - `securenow_human_case_action_update`
 - prompts: `investigate_human_action_row`, `work_human_actions`
 
+`human report` only adds a note: the row stays. `human close` removes it without enforcement.
+Approving a `tune_rule` or `create_exclusion` plan with `human action` records the decision and
+changes nothing: change the rule first, then approve. Only `approve_block` blocks.
+
+### Run the queues with your own agent
+
+```bash
+claude "$(npx -y securenow@latest agent prompt patrol)"                     # read-only pass: a plan
+claude -p "$(npx -y securenow@latest agent prompt patrol --search my-app --confirm-writes)"   --allowedTools "mcp__securenow"                                           # unattended, acts on one app
+```
+
+`soc_patrol` works Alert Review then Requires Human, up to 10 groups and 10 rows per pass
+(`--max-alert-review-groups`, `--max-human-rows`). The API key's scopes are the hard limit: a
+Read Only key cannot change anything; acting needs `notifications:write`, `alerts:write` and
+`rate_limits:write`. Setup for Claude Code, Codex and Cursor: dashboard → Run With Your Agent.
+
 Write tools still require `confirm:true` plus a reason. False positives should stay restrictive to the app, alert rule, path, method/status, user-agent, body pattern, or other exact evidence the AI report supports. Notification IP investigations can include `metadata.matchedSubdetectors`; prefer that exact field over inferring which subdetector fired from the title or sample body.
 
 ### Alerts

package/cli/human.js

@@ -509,13 +509,60 @@ async function report(args, flags) {
     }
     s.stop('Decision report recorded');
     if (flags.json) ui.json(data);
-    else ui.success(`Recorded decision report: ${decisionReport.outcome}`);
+    else {
+      ui.success(`Recorded decision report: ${decisionReport.outcome}`);
+      if (task.ip) ui.info(`A report is a note: the row stays in the queue. To close it without enforcement: securenow human close ${task.notificationId}:${task.ip} --outcome ${decisionReport.outcome}`);
+    }
   } catch (err) {
     s.fail('Failed to record decision report');
     throw err;
   }
 }
 
+const CLOSE_OUTCOMES = ['rate_limited', 'deferred', 'rule_tuning', 'new_alert_rule', 'ambiguous', 'skipped', 'other'];
+
+// Close an IP row without blocking or marking it a false positive ("not now", "rule needs tuning",
+// "already rate-limited"...). Unlike `report`, the row leaves the queue.
+async function close(args, flags) {
+  requireAuth();
+  const ref = args[0];
+  const { task } = await resolveTask(ref, flags);
+  if (!task.ip) {
+    ui.error('`close` is for IP rows. For a case-level plan use: securenow human action <row> --status approved|rejected');
+    process.exit(1);
+  }
+  const outcome = flags.outcome || 'skipped';
+  if (!CLOSE_OUTCOMES.includes(outcome)) {
+    ui.error(`--outcome must be one of: ${CLOSE_OUTCOMES.join(', ')}`);
+    process.exit(1);
+  }
+  const summary = flags.summary || flags.reason;
+  if (!summary) {
+    ui.error('Say why with --reason "..." (and --missing-proof "..." when evidence is missing): the reason is kept on the case.');
+    process.exit(1);
+  }
+
+  if (!flags.yes && !flags.force) {
+    const ok = await ui.confirm(`Close ${task.ip} without blocking it (${outcome})?`);
+    if (!ok) return;
+  }
+
+  const s = ui.spinner(`Closing ${task.ip}`);
+  try {
+    const decisionReport = buildDecisionReport(task, flags, outcome, summary);
+    const data = await api.post(
+      `/notifications/${encodeURIComponent(task.notificationId)}/ips/${encodeURIComponent(task.ip)}/close-no-write`,
+      { reportSource: 'cli', reason: flags.reason || summary, summary, outcome, decisionReport }
+    );
+    s.stop(`${task.ip} closed (${outcome})`);
+    if (flags.json) ui.json(data);
+    else ui.success(`Closed without enforcement: ${task.ip} is out of the queue, nothing was blocked. The reason is on the case.`);
+  } catch (err) {
+    s.fail('Failed to close the row');
+    throw err;
+  }
+}
+
 function mcpPromptText(ref, flags = {}) {
   const rowText = ref ? `Start with human action row/id: ${ref}.` : 'Work the human action queue from most urgent to least urgent.';
   const limit = flags.limit || 10;
@@ -636,6 +683,7 @@ module.exports = {
   block,
   fp,
   report,
+  close,
   prompt,
   work,
   promotions,

package/cli/review.js

@@ -0,0 +1,295 @@
+'use strict';
+
+// Alert Review: "is this rule right?". A rule fired on too many IPs, or on an IP SecureNow treats as
+// your own infrastructure, so it was paused and the run waits for a person. Rows that share one root
+// cause (same rule, route, evidence shape) are grouped so one decision can close them all. Closing a
+// row never blocks or unblocks anything; keeping a rule on is the only write to the rule itself.
+
+const { api, requireAuth } = require('./client');
+const ui = require('./ui');
+
+const OUTCOMES = ['rule_tuning', 'false_positive', 'clean', 'deferred', 'new_alert_rule', 'rate_limited', 'ambiguous', 'skipped', 'other'];
+
+const VERDICTS = {
+  false_positive_pattern: 'looks benign',
+  rule_tuning: 'rule needs tuning',
+  real_probe: 'real probe',
+  ambiguous: 'unclear',
+};
+
+function verdictLabel(decisionTypes = {}) {
+  const keys = Object.keys(decisionTypes);
+  if (keys.length === 0) return '-';
+  if (keys.length > 1) return 'mixed';
+  return VERDICTS[keys[0]] || keys[0];
+}
+
+// Alerts carry app keys; print the names people know them by.
+async function appNames() {
+  try {
+    const data = await api.get('/applications');
+    return new Map((data.applications || []).map((app) => [app.key, app.name]));
+  } catch {
+    return new Map();
+  }
+}
+
+function namesOf(keys, names) {
+  return (keys || []).map((key) => names.get(key) || key).join(', ') || '-';
+}
+
+function isNotificationId(ref) {
+  return /^[0-9a-f]{24}$/i.test(String(ref || ''));
+}
+
+async function fetchGroups(flags = {}) {
+  const query = { page: flags.page || 1, limit: flags.limit || 20 };
+  if (flags.search) query.search = flags.search;
+  return api.get('/notifications/alert-review-runs', { query });
+}
+
+// A group is named by its row on the current page or by its root-cause key (arc_...).
+async function resolveGroup(ref, flags = {}) {
+  if (!ref) {
+    ui.error('Group row or root-cause key required. Use `securenow review list` first.');
+    process.exit(1);
+  }
+  const text = String(ref).trim();
+  if (/^\d+$/.test(text)) {
+    // Rows are numbered across pages, as `review list` prints them.
+    const row = Math.max(1, parseInt(text, 10));
+    const limit = Number(flags.limit) || 20;
+    const data = await fetchGroups({ ...flags, limit, page: Math.ceil(row / limit) });
+    const group = (data.groups || [])[(row - 1) % limit];
+    if (!group) {
+      ui.error(`Row ${text} was not found. Run \`securenow review list\` again: the queue may have changed.`);
+      process.exit(1);
+    }
+    return group;
+  }
+  const data = await api.get('/notifications/alert-review-runs', { query: { rootCauseKey: text, limit: 1 } });
+  const group = (data.groups || [])[0];
+  if (!group) {
+    ui.error(`No open group "${text}". It may already be closed.`);
+    process.exit(1);
+  }
+  return group;
+}
+
+function requireReason(flags) {
+  const reason = flags.reason || flags.summary;
+  if (!reason) {
+    ui.error('Say why with --reason "...": the reason is kept on the alert as its decision report.');
+    process.exit(1);
+  }
+  return reason;
+}
+
+function requireOutcome(flags, fallback) {
+  const outcome = flags.outcome || fallback;
+  if (!OUTCOMES.includes(outcome)) {
+    ui.error(`--outcome must be one of: ${OUTCOMES.join(', ')}`);
+    process.exit(1);
+  }
+  return outcome;
+}
+
+async function list(args, flags) {
+  requireAuth();
+  const s = ui.spinner('Fetching Alert Review');
+  let data;
+  try {
+    data = await fetchGroups(flags);
+    const summary = data.summary || {};
+    s.stop(`${summary.totalRuns ?? 0} alert run${summary.totalRuns === 1 ? '' : 's'} to review in ${summary.totalGroups ?? 0} group${summary.totalGroups === 1 ? '' : 's'}`);
+  } catch (err) {
+    s.fail('Failed to fetch Alert Review');
+    throw err;
+  }
+  if (flags.json) { ui.json(data); return; }
+
+  const groups = data.groups || [];
+  console.log('');
+  if (!groups.length) {
+    ui.info('Nothing to review: no paused or noisy rule is waiting for a decision.');
+    console.log('');
+    return;
+  }
+  const offset = ((data.pagination?.page || 1) - 1) * (data.pagination?.limit || groups.length);
+  const rows = groups.map((group, index) => [
+    String(offset + index + 1),
+    String(group.count || 0),
+    ui.truncate(group.rootCause?.detectionName || group.title || '-', 40),
+    ui.truncate(group.rootCause?.routeTemplate || '-', 28),
+    verdictLabel(group.decisionTypes),
+    group.batchActionPreview?.canApplyOneDecision ? 'yes' : 'no',
+    group.lastOccurredAt ? ui.timeAgo(group.lastOccurredAt) : '-',
+  ]);
+  ui.table(['Row', 'Runs', 'Rule', 'Route', 'Looks like', 'One decision', 'Last'], rows, { maxColWidth: 44 });
+  console.log('');
+  ui.info('Inspect a group:            securenow review show <row>');
+  ui.info('Rule is right, keep it on:  securenow review keep <notificationId> --reason "..."');
+  ui.info('Close a whole group:        securenow review group <row> --outcome rule_tuning --reason "..." [--preview]');
+  console.log('');
+}
+
+function printRun(run, names) {
+  ui.keyValue([
+    ['Alert', `${run.title || '-'} ${ui.c.dim(run.notificationId)}`],
+    ['Rule', `${run.alertRule?.name || run.rootCause?.alertRuleName || '-'}${run.alertRule?.status ? ` (${run.alertRule.status})` : ''}`],
+    ['Route', run.rootCause?.routeTemplate || '-'],
+    ['Looks like', VERDICTS[run.rootCause?.decisionType] || run.rootCause?.decisionType || '-'],
+    ['Who sent it', run.rootCause?.attributionType || '-'],
+    ['Apps', namesOf(run.applications, names)],
+    ['IP', run.primaryIp || '-'],
+    ['Evidence', `${run.evidenceQuality?.score ?? '-'} / 100${run.proofContract?.missingProof?.length ? `, missing: ${run.proofContract.missingProof.join(', ')}` : ''}`],
+    ['Proposed guard', run.rootCause?.proposedGuard || '-'],
+    ['Last seen', run.lastOccurredAt ? ui.timeAgo(run.lastOccurredAt) : '-'],
+  ]);
+}
+
+async function show(args, flags) {
+  requireAuth();
+  const ref = args[0];
+  if (isNotificationId(ref)) {
+    const data = await api.get(`/notifications/alert-review-runs/${ref}`);
+    if (flags.json) { ui.json(data); return; }
+    ui.heading('Alert run');
+    printRun(data.run, await appNames());
+    if (data.group) {
+      console.log('');
+      ui.info(`${data.group.count} open run${data.group.count === 1 ? '' : 's'} share this root cause (${data.group.key}).`);
+    }
+    console.log('');
+    return;
+  }
+
+  const group = await resolveGroup(ref, flags);
+  if (flags.json) { ui.json(group); return; }
+  const names = await appNames();
+  ui.heading(group.title || 'Alert Review group');
+  ui.keyValue([
+    ['Key', group.key],
+    ['Runs', String(group.count)],
+    ['Looks like', verdictLabel(group.decisionTypes)],
+    ['Apps', namesOf(group.applications, names)],
+    ['IPs', `${(group.ips || []).length}${group.ips?.length ? `: ${group.ips.slice(0, 5).join(', ')}${group.ips.length > 5 ? ' ...' : ''}` : ''}`],
+    ['Evidence', `${group.evidenceQuality?.min ?? '-'}-${group.evidenceQuality?.max ?? '-'} / 100`],
+    ['Proposed guard', group.rootCause?.proposedGuard || '-'],
+    ['One decision', group.batchActionPreview?.canApplyOneDecision ? 'yes' : `no: ${group.batchActionPreview?.reason || 'single run'}`],
+  ]);
+  if (group.runs?.length) {
+    console.log('');
+    ui.table(['Alert id', 'IP', 'Evidence', 'Last'], group.runs.map((run) => [
+      run.notificationId,
+      run.primaryIp || '-',
+      String(run.evidenceQuality?.score ?? '-'),
+      run.lastOccurredAt ? ui.timeAgo(run.lastOccurredAt) : '-',
+    ]));
+  }
+  console.log('');
+  ui.info(`One run:   securenow review show <alert id>`);
+  ui.info(`All runs:  securenow review group ${group.key} --outcome rule_tuning --reason "..." --preview`);
+  console.log('');
+}
+
+async function keep(args, flags) {
+  requireAuth();
+  const id = args[0];
+  if (!isNotificationId(id)) {
+    ui.error('Usage: securenow review keep <notificationId> --reason "..." --yes');
+    process.exit(1);
+  }
+  const reason = requireReason(flags);
+  if (!flags.yes && !flags.force) {
+    ui.warn('This turns the rule back on and stops it from pausing itself again.');
+    const ok = await ui.confirm('Keep the rule on and close this run?');
+    if (!ok) return;
+  }
+  const s = ui.spinner('Keeping the rule on');
+  try {
+    const data = await api.post(`/notifications/alert-review-runs/${id}/keep-alive`, { confirm: true, reason, reportSource: 'cli' });
+    s.stop(`"${data.alertRule?.name || 'Rule'}" is ${data.verification?.ruleActive ? 'on' : data.alertRule?.status || 'unchanged'}; the run is closed`);
+    if (flags.json) ui.json(data);
+  } catch (err) {
+    s.fail('Failed to keep the rule on');
+    throw err;
+  }
+}
+
+async function closeOne(args, flags, mode) {
+  requireAuth();
+  const id = args[0];
+  if (!isNotificationId(id)) {
+    ui.error(`Usage: securenow review ${mode} <notificationId> ${mode === 'close' ? '--outcome rule_tuning ' : ''}--reason "..." --yes`);
+    process.exit(1);
+  }
+  const outcome = requireOutcome(flags, 'skipped');
+  const reason = requireReason(flags);
+  if (!flags.yes && !flags.force) {
+    const ok = await ui.confirm(`${mode === 'close' ? 'Close' : 'Dismiss'} this run (${outcome})? Nothing is blocked or unblocked.`);
+    if (!ok) return;
+  }
+  const route = mode === 'close' ? 'resolve' : 'dismiss';
+  const s = ui.spinner(mode === 'close' ? 'Closing the run' : 'Dismissing the run');
+  try {
+    const data = await api.post(`/notifications/alert-review-runs/${id}/${route}`, {
+      confirm: true,
+      outcome,
+      reason,
+      summary: flags.summary || reason,
+      reportSource: 'cli',
+    });
+    s.stop(data.alreadyClosed ? 'Already closed' : `Run ${mode === 'close' ? 'closed' : 'dismissed'} (${outcome}); the reason is on the alert`);
+    if (flags.json) ui.json(data);
+  } catch (err) {
+    s.fail(`Failed to ${mode} the run`);
+    throw err;
+  }
+}
+
+async function group(args, flags) {
+  requireAuth();
+  const target = await resolveGroup(args[0], flags);
+  const preview = Boolean(flags.preview);
+  const outcome = preview ? flags.outcome : requireOutcome(flags);
+  const reason = preview ? flags.reason : requireReason(flags);
+  if (!preview && !flags.yes && !flags.force) {
+    ui.warn(`This closes ${target.count} run${target.count === 1 ? '' : 's'} of "${target.title}". Nothing is blocked or unblocked.`);
+    const ok = await ui.confirm(`Close the group (${outcome})?`);
+    if (!ok) return;
+  }
+  const s = ui.spinner(preview ? 'Previewing the group decision' : 'Closing the group');
+  try {
+    const data = await api.post('/notifications/alert-review-runs/apply-group-decision', {
+      rootCauseKey: target.key,
+      previewOnly: preview,
+      confirm: !preview,
+      allowMixed: Boolean(flags['allow-mixed']),
+      outcome,
+      reason,
+      summary: flags.summary || reason,
+      reportSource: 'cli',
+    });
+    if (preview) {
+      s.stop(`Would close ${data.willApplyCount} run${data.willApplyCount === 1 ? '' : 's'}`);
+      if (target.mixed) ui.warn('Mixed group: rows disagree on verdict or sender. Review each row, then pass --allow-mixed.');
+    } else {
+      s.stop(`Closed ${data.closedCount} of ${data.requestedCount}${data.failedCount ? `, ${data.failedCount} failed` : ''}; ${data.verification?.remainingOpenInGroup ?? 0} still open in the group`);
+    }
+    if (flags.json) ui.json(data);
+  } catch (err) {
+    s.fail(preview ? 'Preview failed' : 'Failed to close the group');
+    throw err;
+  }
+}
+
+module.exports = {
+  list,
+  show,
+  keep,
+  close: (args, flags) => closeOne(args, flags, 'close'),
+  dismiss: (args, flags) => closeOne(args, flags, 'dismiss'),
+  group,
+  OUTCOMES,
+};

package/cli.js

@@ -249,8 +249,8 @@ const COMMANDS = {
     defaultSub: 'list',
   },
   human: {
-    desc: 'Work the human action queue prepared by SecureNow AI',
-    usage: 'securenow human <list|show|block|fp|report|action|prompt|work|promotions|approve-promotion|deny-promotion> [row|notificationId:ip|request-id] [options]',
+    desc: 'Requires Human: decisions SecureNow prepared but won\'t make alone (block an IP, false positive, close, approve a plan)',
+    usage: 'securenow human <list|show|block|fp|close|report|action|prompt|work|promotions|approve-promotion|deny-promotion> [row|notificationId:ip|request-id] [options]',
     flags: {
       json: 'Output as JSON',
       note: 'With approve-promotion / deny-promotion: a note recorded with the decision',
@@ -284,8 +284,9 @@ const COMMANDS = {
       show: { desc: 'Show one row with AI report, proofs, investigation steps, and trace links', usage: 'securenow human show <row|notificationId:ip>', run: (a, f) => require('./cli/human').show(a, f) },
       block: { desc: 'Approve the AI block recommendation for a row', usage: 'securenow human block <row|notificationId:ip> --yes --reason "..."', run: (a, f) => require('./cli/human').block(a, f) },
       fp: { desc: 'Mark a row as a scoped false positive', usage: 'securenow human fp <row|notificationId:ip> --yes --reason "..."', run: (a, f) => require('./cli/human').fp(a, f) },
-      report: { desc: 'Record a structured decision report on a row without changing status', usage: 'securenow human report <row|notificationId:ip> --yes --outcome ambiguous --summary "..."', run: (a, f) => require('./cli/human').report(a, f) },
-      action: { desc: 'Approve/reject/execute a case-level proposed action', usage: 'securenow human action <row|notificationId> [actionKey] --status approved --yes --reason "..."', run: (a, f) => require('./cli/human').action(a, f) },
+      close: { desc: 'Close an IP row without blocking it (not now, rule needs tuning, rate-limited...): it leaves the queue, the reason stays on the case', usage: 'securenow human close <row|notificationId:ip> --outcome deferred|rule_tuning|new_alert_rule|ambiguous|skipped|rate_limited|other --reason "..." [--missing-proof "..."] --yes', run: (a, f) => require('./cli/human').close(a, f) },
+      report: { desc: 'Add a decision note to a row; the row stays in the queue (use close to remove it)', usage: 'securenow human report <row|notificationId:ip> --yes --outcome ambiguous --summary "..."', run: (a, f) => require('./cli/human').report(a, f) },
+      action: { desc: 'Approve/reject a case-level plan. approve_block blocks; approving tune_rule/create_exclusion only records it (change the rule first)', usage: 'securenow human action <row|notificationId> [actionKey] --status approved --yes --reason "..."', run: (a, f) => require('./cli/human').action(a, f) },
       prompt: { desc: 'Print a Codex/Claude MCP prompt for row or queue work', usage: 'securenow human prompt [row|notificationId:ip] [--limit 10]', run: (a, f) => require('./cli/human').prompt(a, f) },
       work: { desc: 'List the queue and print the MCP runbook to work it deeply', usage: 'securenow human work [--limit 10]', run: (a, f) => require('./cli/human').work(a, f) },
       promotions: { desc: 'List requests to promote a test-mode rule to prod (agents ask, a person decides)', usage: 'securenow human promotions [--status pending|approved|denied|all]', run: (a, f) => require('./cli/human').promotions(a, f) },
@@ -294,6 +295,32 @@ const COMMANDS = {
     },
     defaultSub: 'list',
   },
+  review: {
+    desc: 'Alert Review: "is this rule right?" Rules that fired too wide or on your own infrastructure, paused until someone decides',
+    usage: 'securenow review <list|show|keep|close|dismiss|group> [row|rootCauseKey|notificationId] [options]',
+    flags: {
+      json: 'Output as JSON',
+      page: 'Groups page number',
+      limit: 'Groups page size',
+      search: 'Search rule, route, IP, or app name',
+      outcome: 'Why it closes: rule_tuning, false_positive, clean, deferred, new_alert_rule, rate_limited, ambiguous, skipped, other',
+      reason: 'Why, in one sentence: kept on the alert as its decision report',
+      summary: 'Longer decision summary (defaults to --reason)',
+      preview: 'With group: show what would close, change nothing',
+      'allow-mixed': 'With group: close a group whose rows disagree, after reviewing every row',
+      yes: 'Confirm without prompting',
+      force: 'Alias for --yes',
+    },
+    sub: {
+      list: { desc: 'List open alert runs grouped by root cause (one decision can close a group)', usage: 'securenow review list [--search lab-auth]', run: (a, f) => require('./cli/review').list(a, f) },
+      show: { desc: 'Show a group (row or arc_ key) or one alert run (notification id)', usage: 'securenow review show <row|rootCauseKey|notificationId>', run: (a, f) => require('./cli/review').show(a, f) },
+      keep: { desc: 'The rule is right: turn it back on, stop it pausing itself, close the run', usage: 'securenow review keep <notificationId> --reason "..." --yes', run: (a, f) => require('./cli/review').keep(a, f) },
+      close: { desc: 'Close one run with an outcome; nothing is blocked or unblocked', usage: 'securenow review close <notificationId> --outcome rule_tuning --reason "..." --yes', run: (a, f) => require('./cli/review').close(a, f) },
+      dismiss: { desc: 'Dismiss one run (not worth acting on); nothing is blocked or unblocked', usage: 'securenow review dismiss <notificationId> --reason "..." --yes', run: (a, f) => require('./cli/review').dismiss(a, f) },
+      group: { desc: 'Close every run in a group with one decision; --preview first', usage: 'securenow review group <row|rootCauseKey> --outcome rule_tuning --reason "..." [--preview] [--allow-mixed] --yes', run: (a, f) => require('./cli/review').group(a, f) },
+    },
+    defaultSub: 'list',
+  },
   agent: {
     desc: 'SOC runbook prompts for running the SecureNow agent work with your own harness (Claude, Hermes, OpenClaw, ...)',
     usage: 'securenow agent <prompt|prompts> [patrol|alert-review|human-queue] [options]',
@@ -854,7 +881,7 @@ function showHelp(commandName) {
     'Authentication': ['login', 'logout', 'whoami', 'credentials'],
     'Applications': ['apps', 'init', 'status'],
     'Observe': ['traces', 'logs', 'analytics'],
-    'Detect & Respond': ['human', 'notifications', 'alerts', 'fp'],
+    'Detect & Respond': ['human', 'review', 'notifications', 'alerts', 'fp'],
     'Investigate': ['ip', 'forensics'],
     'Firewall': ['firewall'],
     'Remediation': ['automation', 'ratelimit', 'challenge', 'blocklist', 'revoke', 'allowlist', 'trusted'],

package/mcp/catalog.js

@@ -532,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 }),
     }),
   },
   {
@@ -747,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,
@@ -792,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,
@@ -2463,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 },
     ],
   },
@@ -2595,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.',
@@ -2603,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'),
         },
@@ -2632,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'),
@@ -2651,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.',
             '',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securenow",
-  "version": "8.18.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",