severally-mcp 2.1.0 → 2.4.0

package/src/parse-result.mjs

@@ -60,14 +60,26 @@ export function extractJson(text) {
     let esc = false;
     for (let i = start; i < trimmed.length; i++) {
       const ch = trimmed[i];
-      if (esc) { esc = false; continue; }
-      if (ch === '\\') { esc = true; continue; }
-      if (ch === '"') { inStr = !inStr; continue; }
+      if (esc) {
+        esc = false;
+        continue;
+      }
+      if (ch === '\\') {
+        esc = true;
+        continue;
+      }
+      if (ch === '"') {
+        inStr = !inStr;
+        continue;
+      }
       if (inStr) continue;
       if (ch === '{') depth++;
       else if (ch === '}') {
         depth--;
-        if (depth === 0) { candidates.push(trimmed.slice(start, i + 1)); break; }
+        if (depth === 0) {
+          candidates.push(trimmed.slice(start, i + 1));
+          break;
+        }
       }
     }
   }
@@ -75,7 +87,9 @@ export function extractJson(text) {
     try {
       const parsed = JSON.parse(c);
       if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed;
-    } catch { /* try the next candidate */ }
+    } catch {
+      /* try the next candidate */
+    }
   }
   return null;
 }
@@ -101,7 +115,7 @@ function mapList(raw, fields, { requiredField, idPrefix = null }) {
 
 /**
  * @param {object|string} raw  parsed JSON object, or raw text to mine one out of
- * @returns {{result: object, quality: {structured_output: boolean, missing_sections: string[]}}}
+ * @returns {{result: object, quality: {missing_sections: string[], findings_without_grounds: number, unsourced: boolean, list_truncated?: Record<string, number>}}}
  */
 export function normalizeResult(raw) {
   const objIn = typeof raw === 'string' ? extractJson(raw) : raw;
@@ -120,37 +134,78 @@ export function normalizeResult(raw) {
     confidence: level(src.confidence),
     evidence_basis: basis(src.evidence_basis),
     stance: stance(src.stance),
-    findings: mapList(src.findings, {
-      point: 'text', grounds: 'text', impact: 'text', severity: 'level', confidence: 'level',
-    }, { requiredField: 'point', idPrefix: 'f' }),
-    alternatives: mapList(src.alternatives, {
-      option: 'text', tradeoffs: 'text', when_preferred: 'text',
-    }, { requiredField: 'option' }),
-    unknowns: mapList(src.unknowns, {
-      item: 'text', why_it_matters: 'text', how_to_obtain: 'text',
-    }, { requiredField: 'item', idPrefix: 'u' }),
-    decision_changers: mapList(src.decision_changers, {
-      condition: 'text', changes_to: 'text',
-    }, { requiredField: 'condition' }),
-    next_checks: mapList(src.next_checks, {
-      check: 'text', method: 'text', expected_signal: 'text',
-    }, { requiredField: 'check', idPrefix: 'c' }),
-    remaining_disagreements: mapList(src.remaining_disagreements, {
-      topic: 'text', your_position: 'text', why_unresolved: 'text',
-    }, { requiredField: 'topic' }),
+    findings: mapList(
+      src.findings,
+      {
+        point: 'text',
+        grounds: 'text',
+        impact: 'text',
+        severity: 'level',
+        confidence: 'level',
+      },
+      { requiredField: 'point', idPrefix: 'f' },
+    ),
+    alternatives: mapList(
+      src.alternatives,
+      {
+        option: 'text',
+        tradeoffs: 'text',
+        when_preferred: 'text',
+      },
+      { requiredField: 'option' },
+    ),
+    unknowns: mapList(
+      src.unknowns,
+      {
+        item: 'text',
+        why_it_matters: 'text',
+        how_to_obtain: 'text',
+      },
+      { requiredField: 'item', idPrefix: 'u' },
+    ),
+    decision_changers: mapList(
+      src.decision_changers,
+      {
+        condition: 'text',
+        changes_to: 'text',
+      },
+      { requiredField: 'condition' },
+    ),
+    next_checks: mapList(
+      src.next_checks,
+      {
+        check: 'text',
+        method: 'text',
+        expected_signal: 'text',
+      },
+      { requiredField: 'check', idPrefix: 'c' },
+    ),
+    remaining_disagreements: mapList(
+      src.remaining_disagreements,
+      {
+        topic: 'text',
+        your_position: 'text',
+        why_unresolved: 'text',
+      },
+      { requiredField: 'topic' },
+    ),
     references: (Array.isArray(src.references) ? src.references : [])
       .slice(0, O.referencesMax)
-      .map((r) => (r && typeof r === 'object'
-        ? { title: clampText(r.title, 300), url: clampText(r.url, 1000), relevance: clampText(r.relevance, 600) }
-        : { title: clampText(r, 300), url: null, relevance: null }))
+      .map((r) =>
+        r && typeof r === 'object'
+          ? { title: clampText(r.title, 300), url: clampText(r.url, 1000), relevance: clampText(r.relevance, 600) }
+          : { title: clampText(r, 300), url: null, relevance: null },
+      )
       .filter((r) => r.title || r.url),
   };
 
   // The lists are cut to O.listMax before anything else looks at them; say how
   // long the ones that were cut had been, so the cut is not silent.
-  const listTruncated = Object.fromEntries(['findings', 'alternatives', 'unknowns', 'decision_changers', 'next_checks', 'remaining_disagreements']
-    .filter((k) => Array.isArray(src[k]) && src[k].length > O.listMax)
-    .map((k) => [k, src[k].length]));
+  const listTruncated = Object.fromEntries(
+    ['findings', 'alternatives', 'unknowns', 'decision_changers', 'next_checks', 'remaining_disagreements']
+      .filter((k) => Array.isArray(src[k]) && src[k].length > O.listMax)
+      .map((k) => [k, src[k].length]),
+  );
 
   const missing = RESULT_KEYS.filter((k) => {
     const v = result[k];

package/src/platform.mjs

@@ -36,13 +36,9 @@ export function findCommand(command, { cwd = process.cwd(), env = process.env }
   if (typeof command !== 'string' || !command) return null;
   cwd = path.resolve(cwd);
   const windows = process.platform === 'win32';
-  const value = (name) => env[windows
-    ? Object.keys(env).find((key) => key.toUpperCase() === name) : name];
+  const value = (name) => env[windows ? Object.keys(env).find((key) => key.toUpperCase() === name) : name];
   const explicit = command.includes('/') || (windows && command.includes('\\'));
-  const dirs = explicit ? [cwd] : [
-    ...(windows ? [cwd] : []),
-    ...(value('PATH') ?? '').split(path.delimiter).filter(Boolean),
-  ];
+  const dirs = explicit ? [cwd] : [...(windows ? [cwd] : []), ...(value('PATH') ?? '').split(path.delimiter).filter(Boolean)];
   for (const dir of dirs) {
     // Absolute candidates prevent which's own cwd lookup from resolving a
     // wrapper in the server directory instead of the child's directory.
@@ -56,7 +52,9 @@ export function findCommand(command, { cwd = process.cwd(), env = process.env }
       if (!fs.statSync(candidate).isFile()) return null;
       fs.accessSync(candidate, fs.constants.X_OK);
       return candidate;
-    } catch { /* not installed */ }
+    } catch {
+      /* not installed */
+    }
   }
   return null;
 }

package/src/policy.mjs

@@ -7,7 +7,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { parseJsonc } from './jsonc.mjs';
 import { findCommand } from './platform.mjs';
-import { buildConsultants, CLI_IDS, normalizeName } from './consultants.mjs';
+import { buildConsultants, normalizeName } from './consultants.mjs';
 
 // One file, read once at start, so an operator configures a machine in a
 // single place instead of editing each client's MCP registration. Precedence
@@ -17,10 +17,10 @@ import { buildConsultants, CLI_IDS, normalizeName } from './consultants.mjs';
 const CONFIG_HOME = process.env.SEVERALLY_HOME || path.join(os.homedir(), '.severally');
 // .jsonc first, for operators whose editor treats comments in a .json file as
 // an error; both are read the same way, comments and all.
-const CONFIG_PATH = process.env.SEVERALLY_CONFIG
-  || [path.join(CONFIG_HOME, 'config.jsonc'), path.join(CONFIG_HOME, 'config.json')]
-    .find((p) => fs.existsSync(p))
-  || path.join(CONFIG_HOME, 'config.json');
+const CONFIG_PATH =
+  process.env.SEVERALLY_CONFIG ||
+  [path.join(CONFIG_HOME, 'config.jsonc'), path.join(CONFIG_HOME, 'config.json')].find((p) => fs.existsSync(p)) ||
+  path.join(CONFIG_HOME, 'config.json');
 
 let configError = null;
 const CONFIG = (() => {
@@ -35,21 +35,53 @@ const CONFIG = (() => {
   }
 })();
 
-// Every mistake in the file, not only a syntax error. A config with any of
-// them is not run on defaults: the server still starts, so the operator can
-// read why, but every consultation is refused (jobs.mjs) -- falling back would
-// quietly re-enable a CLI the operator turned off.
+// A mistake that leaves the whole file untrustworthy (unreadable, an unknown
+// top-level key, a section of the wrong shape) is not run on defaults: the
+// server still starts, so the operator can read why, but every consultation is
+// refused (jobs.mjs) -- falling back would quietly re-enable a CLI the
+// operator turned off. A mistake inside one consultant or one CLI only takes
+// that one out of use, with the reason.
 const BUILT = buildConsultants(CONFIG);
-if (!configError && BUILT.problems.length) configError = `${CONFIG_PATH}: ${BUILT.problems.join('; ')}`;
+if (!configError && BUILT.global.length) configError = `${CONFIG_PATH}: ${BUILT.global.join('; ')}`;
+// A value that is neither, from the environment, cannot be read as either: reading it as "on" would open the web.
+if (!configError && ![undefined, '', 'on', 'off'].includes(process.env.SEVERALLY_NETWORK)) {
+  configError = `SEVERALLY_NETWORK must be "on" or "off", not ${JSON.stringify(process.env.SEVERALLY_NETWORK)}`;
+}
 const FROM = configError ? buildConsultants({}) : BUILT;
+const LOCAL = configError ? [] : BUILT.problems.filter((p) => !BUILT.global.includes(p));
 
-/** What is wrong with the config file, or null. Reported at startup; while set, nothing can be started. */
+/** What is wrong with the config file as a whole, or null. Reported at startup; while set, nothing can be started. */
 export function configProblem() {
   return configError;
 }
 
+/** The mistakes kept to one consultant or one CLI, each of which is out of use until fixed. */
+export function configWarnings() {
+  return LOCAL.map((p) => `${CONFIG_PATH}: ${p}`);
+}
+
+/** The names of the consultants out of use because of a mistake in their own config section. */
+export function brokenConsultantNames() {
+  return configError ? [] : Object.keys(BUILT.broken);
+}
+
+/** Why the consultant of this name is out of use because of a config mistake, or null. */
+export function brokenConsultant(name) {
+  const p = !configError && Object.hasOwn(BUILT.broken, name) ? BUILT.broken[name] : null;
+  return p ? `the config file has a mistake in it: ${p.join('; ')}` : null;
+}
+
 const usable = configError ? {} : CONFIG;
-const cfgCli = (id) => (usable.clis && typeof usable.clis === 'object' ? usable.clis[id] ?? {} : {});
+// A CLI whose own section has a mistake is off, whatever else the section says.
+const cfgCli = (id) => {
+  if (Object.hasOwn(BUILT.brokenClis, id) && !configError) {
+    return {
+      enabled: false,
+      note: `turned off: the config file has a mistake in clis.${id}: ${BUILT.brokenClis[id].join('; ')}`,
+    };
+  }
+  return usable.clis && typeof usable.clis === 'object' ? (usable.clis[id] ?? {}) : {};
+};
 const cfgServer = usable.server && typeof usable.server === 'object' ? usable.server : {};
 
 /**
@@ -88,12 +120,23 @@ const str = (name, dflt) => {
 // The CLI a lead runs in, by any everyday name. Only `caller` uses this:
 // which consultant a name reaches is consultants.mjs's resolveConsultant.
 // Object.create(null) so 'constructor' is an unknown name, not a function.
-export const CALLER_ALIASES = Object.freeze(Object.assign(Object.create(null), {
-  codex: 'codex', gpt: 'codex', chatgpt: 'codex', openai: 'codex',
-  'claude-code': 'claude-code', claude: 'claude-code', anthropic: 'claude-code',
-  antigravity: 'antigravity', agy: 'antigravity', gemini: 'antigravity', google: 'antigravity',
-  opencode: 'opencode', glm: 'opencode',
-}));
+export const CALLER_ALIASES = Object.freeze(
+  Object.assign(Object.create(null), {
+    codex: 'codex',
+    gpt: 'codex',
+    chatgpt: 'codex',
+    openai: 'codex',
+    'claude-code': 'claude-code',
+    claude: 'claude-code',
+    anthropic: 'claude-code',
+    antigravity: 'antigravity',
+    agy: 'antigravity',
+    gemini: 'antigravity',
+    google: 'antigravity',
+    opencode: 'opencode',
+    glm: 'opencode',
+  }),
+);
 
 export const CALLER_INPUTS = Object.freeze(Object.keys(CALLER_ALIASES));
 
@@ -176,18 +219,34 @@ export const POLICY = Object.freeze({
   // a consultant's business.
   clis: Object.freeze({
     codex: Object.freeze({
-      cli: CODEX_BIN, available: isEnabled('codex', CODEX_BIN), note: disabledNote('codex'), label: 'Codex CLI', ...extras('codex'),
+      cli: CODEX_BIN,
+      available: isEnabled('codex', CODEX_BIN),
+      note: disabledNote('codex'),
+      label: 'Codex CLI',
+      ...extras('codex'),
     }),
     'claude-code': Object.freeze({
-      cli: CLAUDE_BIN, available: isEnabled('claude-code', CLAUDE_BIN), note: disabledNote('claude-code'), label: 'Claude Code CLI', ...extras('claude-code'),
+      cli: CLAUDE_BIN,
+      available: isEnabled('claude-code', CLAUDE_BIN),
+      note: disabledNote('claude-code'),
+      label: 'Claude Code CLI',
+      ...extras('claude-code'),
     }),
     // Where the real Antigravity credentials live is credentialsHome() below,
     // not a field here: the sandbox reads it per job (see timeoutMs()).
     antigravity: Object.freeze({
-      cli: AGY_BIN, available: isEnabled('antigravity', AGY_BIN), note: disabledNote('antigravity'), label: 'Antigravity CLI', ...extras('antigravity'),
+      cli: AGY_BIN,
+      available: isEnabled('antigravity', AGY_BIN),
+      note: disabledNote('antigravity'),
+      label: 'Antigravity CLI',
+      ...extras('antigravity'),
     }),
     opencode: Object.freeze({
-      cli: OPENCODE_BIN, available: isEnabled('opencode', OPENCODE_BIN), note: disabledNote('opencode'), label: 'OpenCode CLI', ...extras('opencode'),
+      cli: OPENCODE_BIN,
+      available: isEnabled('opencode', OPENCODE_BIN),
+      note: disabledNote('opencode'),
+      label: 'OpenCode CLI',
+      ...extras('opencode'),
       // opencode.json `provider` definitions copied into the sandbox config:
       // the only way to reach a provider the sandbox's empty HOME would not
       // know, such as a local OpenAI-compatible server.
@@ -218,6 +277,10 @@ export const POLICY = Object.freeze({
   // clients allow a tool call, so a long wait does not blow up as a client-side
   // timeout while the consultation is still healthy; a client registration
   // that is known to wait longer raises it (scripts/install.mjs).
+  // "off" takes the web away from every consultation, whatever the request
+  // asks; "on" leaves it to each request's own network.
+  // Either source can close it; neither can reopen what the other closed.
+  network: [process.env.SEVERALLY_NETWORK, cfgServer.network].includes('off') ? 'off' : 'on',
   maxWaitMs: limit('SEVERALLY_MAX_WAIT_MS', cfgServer.max_wait_ms, 45_000, 0, 600_000),
 
   input: Object.freeze({
@@ -305,18 +368,53 @@ export function opencodeCredentialsHome() {
 // and never copied by expose_paths; Codex's read-only sandbox cannot express
 // path rules, which the boundary record says.
 export const PROTECTED_HOME_PATHS = Object.freeze([
-  '.ssh', '.gnupg', '.aws', '.azure', '.kube', '.docker', '.config/gcloud', '.config/gh', '.config/hub',
-  '.netrc', '.npmrc', '.pypirc', '.git-credentials', '.cargo/credentials', '.cargo/credentials.toml',
-  '.terraform.d', '.vault-token', 'Library/Keychains',
-  '.codex', '.claude', '.claude.json', '.gemini', '.config/opencode', '.local/share/opencode',
+  '.ssh',
+  '.gnupg',
+  '.aws',
+  '.azure',
+  '.kube',
+  '.docker',
+  '.config/gcloud',
+  '.config/gh',
+  '.config/hub',
+  '.netrc',
+  '.npmrc',
+  '.pypirc',
+  '.git-credentials',
+  '.cargo/credentials',
+  '.cargo/credentials.toml',
+  '.terraform.d',
+  '.vault-token',
+  'Library/Keychains',
+  '.codex',
+  '.claude',
+  '.claude.json',
+  '.gemini',
+  '.config/opencode',
+  '.local/share/opencode',
 ]);
 // Under POLICY.home, wherever the operator moved it.
-const PROTECTED_SEVERALLY_PATHS = Object.freeze(['history', 'backups', 'config.json', 'config.jsonc', 'homes',
+const PROTECTED_SEVERALLY_PATHS = Object.freeze([
+  'history',
+  'backups',
+  'config.json',
+  'config.jsonc',
+  'homes',
   // Where homes lived before 1.7: one left by an interrupted run can still hold an auth.json copy.
-  'jobs/*/home']);
+  'jobs/*/home',
+]);
 // File names protected wherever they are.
 export const PROTECTED_FILE_NAMES = Object.freeze([
-  '.env', '.env.*', '.npmrc', '.netrc', '.pypirc', '.git-credentials', 'id_rsa', 'id_ed25519', 'id_ecdsa', 'id_dsa',
+  '.env',
+  '.env.*',
+  '.npmrc',
+  '.netrc',
+  '.pypirc',
+  '.git-credentials',
+  'id_rsa',
+  'id_ed25519',
+  'id_ecdsa',
+  'id_dsa',
 ]);
 
 /** Absolute protected roots, with forward slashes; `*` stands for one path segment. */
@@ -333,8 +431,9 @@ const escapeRe = (s) => s.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
 export const PATHS_CASE_INSENSITIVE = process.platform === 'win32' || process.platform === 'darwin';
 /** Regex sources: one per protected root, matching it and anything under it. */
 export function protectedRootPatterns(extraRoots = []) {
-  return [...protectedRoots(), ...extraRoots.map((r) => r.replaceAll('\\', '/'))]
-    .map((r) => `^${escapeRe(r.replace(/\/+$/, '')).replaceAll('*', '[^/]+')}(/|$)`);
+  return [...protectedRoots(), ...extraRoots.map((r) => r.replaceAll('\\', '/'))].map(
+    (r) => `^${escapeRe(r.replace(/\/+$/, '')).replaceAll('*', '[^/]+')}(/|$)`,
+  );
 }
 /** Regex sources for PROTECTED_FILE_NAMES, matched against a base name. */
 export function protectedNamePatterns() {
@@ -347,7 +446,11 @@ export function isProtectedPath(abs) {
   const roots = protectedRootPatterns().map((p) => new RegExp(p, flags));
   const names = protectedNamePatterns().map((p) => new RegExp(p, flags));
   let real = abs;
-  try { real = fs.realpathSync.native(abs); } catch { /* missing: check the name as given */ }
+  try {
+    real = fs.realpathSync.native(abs);
+  } catch {
+    /* missing: check the name as given */
+  }
   return [abs, real].some((p) => {
     const fwd = p.replaceAll('\\', '/');
     return roots.some((re) => re.test(fwd)) || names.some((re) => re.test(path.basename(fwd)));
@@ -389,11 +492,15 @@ export function limitsSummary() {
   const by = (f) => Object.fromEntries(list.map((c) => [c.name, f(c)]));
   return {
     available_targets: list.map((c) => c.name),
+    // A consultant or CLI out of use because of a mistake in its own section.
+    ...(LOCAL.length ? { config_mistakes: configWarnings() } : {}),
     clis: by((c) => c.cli),
     models: by((c) => c.model),
     // Per consultant, because they no longer share one budget.
     timeout_ms: by(timeoutMs),
     max_rounds_per_chain: POLICY.maxRounds,
+    // "off": the operator has taken the web away from every consultation.
+    network: POLICY.network,
     max_concurrent_jobs: POLICY.maxConcurrent,
     max_wait_ms: POLICY.maxWaitMs,
     input_char_budget: POLICY.input.totalCharsMax,

package/src/redact.mjs

@@ -1,51 +1,75 @@
 // Credential scrubbing. Applied on the way out (brief sent to the consultant),
 // on the way in (consultant output), and to everything persisted to disk.
 
-const CODE_WORDS = new Set(['true', 'false', 'null', 'none', 'undefined', 'string', 'str', 'number', 'boolean', 'bool', 'int', 'bytes']);
+const CODE_WORDS = new Set([
+  'true',
+  'false',
+  'null',
+  'none',
+  'undefined',
+  'string',
+  'str',
+  'number',
+  'boolean',
+  'bool',
+  'int',
+  'bytes',
+]);
 
 // A password-type value that is code, not a secret: a flag or a type, a
 // variable reference (${X}, $X, process.env.X, os.environ[...]), and -- unless
 // it is a long value under a full PASSWORD/PASSWD name, which stays masked
 // whatever it looks like -- a dotted name, a call or a borrow (&str).
 function looksLikeCode(name, value) {
-  if (CODE_WORDS.has(value.toLowerCase()) || value.startsWith('${') || /^\$[A-Z_][A-Z0-9_]*$/.test(value)
-    || /^(?:process\.env\.|os\.environ\b)/.test(value)) return true;
+  if (
+    CODE_WORDS.has(value.toLowerCase()) ||
+    value.startsWith('${') ||
+    /^\$[A-Z_][A-Z0-9_]*$/.test(value) ||
+    /^(?:process\.env\.|os\.environ\b)/.test(value)
+  )
+    return true;
   if (value.length >= 8 && /^PASSW(?:OR)?D$/i.test(name.split('_').at(-1))) return false;
   return /^[A-Za-z_][\w$]*(?:\.[A-Za-z_$][\w$]*)+$/.test(value) || /^[A-Za-z_][\w$.]*\(/.test(value) || value.startsWith('&');
 }
 
+// A replacement is a string or a function of the match.
+/** @type {Array<[RegExp, any]>} */
 const PATTERNS = [
   // Provider API keys
-  [/\bsk-ant-[A-Za-z0-9_\-]{12,}/g, '[REDACTED:anthropic-key]'],
-  [/\bsk-proj-[A-Za-z0-9_\-]{12,}/g, '[REDACTED:openai-key]'],
-  [/\bsk-[A-Za-z0-9_\-]{20,}/g, '[REDACTED:api-key]'],
+  [/\bsk-ant-[A-Za-z0-9_-]{12,}/g, '[REDACTED:anthropic-key]'],
+  [/\bsk-proj-[A-Za-z0-9_-]{12,}/g, '[REDACTED:openai-key]'],
+  [/\bsk-[A-Za-z0-9_-]{20,}/g, '[REDACTED:api-key]'],
   [/\bgh[pousr]_[A-Za-z0-9]{16,}/g, '[REDACTED:github-token]'],
   [/\bgithub_pat_[A-Za-z0-9_]{20,}/g, '[REDACTED:github-token]'],
   [/\bxox[baprs]-[A-Za-z0-9-]{10,}/g, '[REDACTED:slack-token]'],
   [/https:\/\/hooks\.slack\.com\/services\/T[A-Za-z0-9]+\/B[A-Za-z0-9]+\/[A-Za-z0-9]+/g, '[REDACTED:slack-webhook]'],
   [/\bAKIA[0-9A-Z]{16}\b/g, '[REDACTED:aws-access-key-id]'],
   [/\bASIA[0-9A-Z]{16}\b/g, '[REDACTED:aws-access-key-id]'],
-  [/\bAIza[0-9A-Za-z_\-]{30,}/g, '[REDACTED:google-api-key]'],
+  [/\bAIza[0-9A-Za-z_-]{30,}/g, '[REDACTED:google-api-key]'],
   // Stripe secret and restricted keys (pk_ is public, left alone), npm, GitLab, Hugging Face
   [/\b[sr]k_(?:live|test)_[A-Za-z0-9]{16,}/g, '[REDACTED:stripe-key]'],
   [/\bnpm_[A-Za-z0-9]{30,}/g, '[REDACTED:npm-token]'],
-  [/\bglpat-[A-Za-z0-9_\-]{20,}/g, '[REDACTED:gitlab-token]'],
+  [/\bglpat-[A-Za-z0-9_-]{20,}/g, '[REDACTED:gitlab-token]'],
   [/\bhf_[A-Za-z0-9]{30,}/g, '[REDACTED:huggingface-token]'],
   // JWT / OAuth access tokens (3 base64url segments)
-  [/\beyJ[A-Za-z0-9_\-]{8,}\.[A-Za-z0-9_\-]{8,}\.[A-Za-z0-9_\-]{8,}/g, '[REDACTED:jwt]'],
-  [/\bBearer\s+[A-Za-z0-9._\-]{20,}/gi, 'Bearer [REDACTED:token]'],
+  [/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, '[REDACTED:jwt]'],
+  [/\bBearer\s+[A-Za-z0-9._-]{20,}/gi, 'Bearer [REDACTED:token]'],
   // PEM private keys
   [/-----BEGIN[^-]{0,40}PRIVATE KEY-----[\s\S]*?-----END[^-]{0,40}PRIVATE KEY-----/g, '[REDACTED:private-key]'],
   // The password in a URL's userinfo, also with an empty user (redis://:pass@host)
   [/(:\/\/[^\s:/@]*:)[^\s@/]+(@)/g, '$1[REDACTED]$2'],
   // KEY=value / "token": "value" style assignments
-  [/\b((?:[A-Za-z0-9_]*_)?(?:API_KEY|APIKEY|ACCESS_KEY|PRIVATE_KEY|ACCESS_TOKEN|REFRESH_TOKEN|ID_TOKEN|SECRET_KEY|CLIENT_SECRET|AUTH_TOKEN|CREDENTIALS|ACCOUNTKEY|SHAREDACCESSKEY|SECRET|TOKEN))(["']?\s*[:=]\s*["']?)([^\s"',;)]{8,})/gi,
-    (_m, k, sep, _v) => `${k}${sep}[REDACTED]`],
+  [
+    /\b((?:[A-Za-z0-9_]*_)?(?:API_KEY|APIKEY|ACCESS_KEY|PRIVATE_KEY|ACCESS_TOKEN|REFRESH_TOKEN|ID_TOKEN|SECRET_KEY|CLIENT_SECRET|AUTH_TOKEN|CREDENTIALS|ACCOUNTKEY|SHAREDACCESSKEY|SECRET|TOKEN))(["']?\s*[:=]\s*["']?)([^\s"',;)]{8,})/gi,
+    (_m, k, sep, _v) => `${k}${sep}[REDACTED]`,
+  ],
   // Password-type names, with values from 4 characters; PASS and PWD too (PWD
   // only after `_` or a letter: bare PWD is the working directory). What reads
   // as code rather than a password is left alone (looksLikeCode).
-  [/\b((?:[A-Za-z0-9_]*_)?(?:PASSWORD|PASSWD|PASS|(?<=[A-Za-z_])PWD))(["']?\s*[:=]\s*["']?)([^\s"',;)]{4,})/gi,
-    (m, k, sep, v) => (looksLikeCode(k, v) ? m : `${k}${sep}[REDACTED]`)],
+  [
+    /\b((?:[A-Za-z0-9_]*_)?(?:PASSWORD|PASSWD|PASS|(?<=[A-Za-z_])PWD))(["']?\s*[:=]\s*["']?)([^\s"',;)]{4,})/gi,
+    (m, k, sep, v) => (looksLikeCode(k, v) ? m : `${k}${sep}[REDACTED]`),
+  ],
   // Any environment variable named *_KEY. Upper case only: in code, primary_key,
   // sort_key and idempotency_key name things, not secrets.
   [/\b([A-Z0-9_]+_KEY)(\s*=\s*["']?)([^\s"',;)]{8,})/g, (_m, k, sep, _v) => `${k}${sep}[REDACTED]`],