import { truncate, escapeMd } from './util.js';

import { SCHEMA_VERSION } from './config.js';

const FAILURE_TYPES = new Set([

  'ignored_constraint',

  'misunderstood_goal',

  'scope_drift',

  'wrong_tool_choice',

  'hallucinated_file_or_api',

  'repeated_failed_fix',

  'overbuilt_solution',

  'underbuilt_solution',

  'security_or_privacy_risk',

  'dependency_or_environment_mismatch',

  'format_violation',

  'user_frustration',

  'abandoned_path',

  'user_rejected_action',

  'tool_execution_failed',

  'model_refused',

  'permission_denied',

]);

const REJECTION_KIND_TO_FAILURE_TYPE = {

  user_declined_tool: 'user_rejected_action',

  user_interrupt: 'user_rejected_action',

  user_text_decline: 'user_rejected_action',

  tool_execution_error: 'tool_execution_failed',

  permission_denied: 'permission_denied',

  model_refusal: 'model_refused',

};

function tierForRejection(confidence) {

  if (confidence >= 0.95) return 'verified';

  if (confidence >= 0.8) return 'high';

  if (confidence >= 0.65) return 'confirmed';

  return 'inferred';

}

const CORRECTION_HINT =

  /\b(no|stop|scrap|revert|undo|roll ?back|rip (?:it|that|this) out|back (?:it|that) out|not that|not it|over[- ]?engineered|you forgot|you ignored|that's wrong|that is wrong|i said|instead|redo|re do|go back|wrong|doesn'?t work|didn'?t work|still (failing|broken|wrong|bad)|not what i (asked|wanted|meant))\b/i;

const FRUSTRATION_HINT =

  /\b(sucks|awful|god awful|what the heck|wtf|mad|angry|frustrat|not suffic|i don'?t trust|terrible|bad)\b/i;

const STRONG_FRUSTRATION_RE =

  /\b(god awful|wtf|what the (?:heck|hell)|(?:so |really |this )?sucks|i(?:'m| am) (?:angry|frustrated|furious)|angry and frustrated|makes me (?:angry|mad|furious)|absolutely terrible|piece of (?:junk|garbage|trash|crap))\b/i;

const UNCORROBORATED_RECALL_TYPES = new Set(['user_frustration', 'scope_drift', 'overbuilt_solution']);

const PRIVACY_HINT = /\b(secret|token|api key|apikey|password|redact|privacy|private|local-first|telemetry|upload|cloud)\b/i;

const composeOr = (parts) => new RegExp(parts.map((p) => `(?:${p.re.source})`).join('|'), 'i');

export const SECURITY_INTENT_PARTS = [

  { name: 'credential_lifecycle', re: /\b(?:updated?|rotat(?:e|ed|ing)|regenerat(?:e|ed)|new|replaced?|revoked?)\b[^.]{0,40}\b(?:pat|personal access token|api[- ]?key|access token|secret|credential)s?\b/i },

  { name: 'pat_lifecycle', re: /\bpat\b[^.]{0,30}\b(?:updated?|rotat|regenerat|revoked?)/i },

  { name: 'email_change', re: /\b(?:make|change|set|update|use)\b[^.]{0,30}\bemail\b(?=[^.]*@|[^.]*\bcontact\b|[^.]*\bpublic\b)/i },

  { name: 'do_not_expose', re: /\b(?:don'?t|do not|never)\b[^.]{0,20}\b(?:expose|leak)\b/i },

  { name: 'expose_us', re: /\bexpose us\b/i },

  { name: 'leak_list', re: /\bleak (?:anything|audit|nothing|secrets?|creds?)\b/i },

  { name: 'audit_repos', re: /\b(?:full )?audit\b[^.]{0,40}\b(?:repo|repos|repositor|organization|git commit|commit history)\b/i },

  { name: 'commit_history_audit', re: /\bcommit history\b[^.]{0,30}\b(?:audit|expose|leak|clean)\b/i },

  { name: 'relicensing', re: /\b(?:re-?licens(?:e|ing)|licens(?:e|ing) (?:adjustment|change)|chang(?:e|ing)[^.]{0,15}licens)\b/i },

  { name: 'disable_tests', re: /\b(?:disabl|skip|remov|delet)\w*\b[^.]{0,15}\btests?\b/i },

  { name: 'access_control_change', re: /\b(?:change|modify|update|add|tighten|loosen|fix)\b[^.]{0,20}\b(?:access control|permissions?|rbac|auth flow)\b/i },

];

const SECURITY_INTENT_RE = composeOr(SECURITY_INTENT_PARTS);

const SCOPE_DRIFT_HINT = /\b(don'?t add|do not add|not a web app|keep it local|too much|overbuilt|over[- ]?engineered|over[- ]?kill|scope drift|stay focused|same format|keep .* cli|zero-config cli|way more than|more than i (?:wanted|asked|need)|not a (?:platform|framework|service|product|web ?app|library|server)|a (?:script|function|cli|tool|one[- ]?liner) not|rip (?:it |that |the )?out|too (?:complex|complicated|heavy|big)|simpler than this)\b/i;

const SURPLUS_CUE_RE =

  /\bgold[- ]?plat(?:e|ed|ing)?\b|\bover[- ]?build|\bover[- ]?engineer|\bcannon for a (?:fly|mosquito)\b|\bwrench(?:,)? not a (?:workshop|factory)\b|\btrim (?:it|this) (?:way )?down\b|\bway too (?:much|heavy|big|complex)\b|\bmore than (?:i|we) (?:asked|wanted|needed)\b/i;

const REMOVE_COMPONENTS_RE =

  /\b(?:rip|ditch|drop|strip|tear|gut|remove|delete|cut)\b[^.]{0,60}\b(registry|middleware|daemon|plugin|panel|layer|engine|scheduler|system|framework|theme)\b/i;

const TOOL_HINT = /\b(wrong tool|wrong library|use .* instead|don'?t use|dependency|package|environment|node version|python version|missing module)\b/i;

const HALLUCINATION_HINT = /\b(hallucinat|doesn'?t exist|does not exist|no such file|fake file|fake api|made up)\b/i;

const REPEATED_FIX_HINT = /\b(still failing|still broken|still wrong|again|same error|didn'?t fix|doesn'?t fix|keeps? failing|redo)\b/i;

const UNDERBUILT_HINT = /\b(underbuilt|missing|not enough|too bare|incomplete|you skipped|you missed)\b/i;

const FORMAT_HINT =

  /\b(?:format|reformat|malformed|same structure|exact output)\b|\binvalid (?:json|yaml|xml|format|output|structure|markup|schema)\b/i;

const MISUNDERSTOOD_GOAL_RE =

  /\b(?:that'?s not what i (?:asked|wanted|meant)|not what i (?:asked|wanted|meant)|you (?:misunderstood|got it wrong|missed the point|misread|solved the wrong|optimi[sz]ed the wrong|chose the wrong)|i (?:wanted|meant|asked for|cared about)\b[^.]*\bnot\b|wrong (?:goal|thing|feature|approach|task|problem|axis|optimization|metric)|you built the wrong|that'?s the wrong)\b/i;

const REVERSAL_VERB_RE = /\b(?:rip|nix|scrap|yank|gut|tear|strip|pull)\b[^.]{0,60}\bout\b|\b(?:nix|scrap|yank|gut)\b/i;

const WORDING_SCAN_MAX_CHARS = 1200;

const SIGNAL_PRIORITY = [

  'ignored_constraint',

  'hallucinated_file_or_api',

  'wrong_tool_choice',

  'repeated_failed_fix',

  'scope_drift',

  'overbuilt_solution',

  'underbuilt_solution',

  'dependency_or_environment_mismatch',

  'format_violation',

  'user_frustration',

  'misunderstood_goal',

];

const STOPWORDS = new Set([

  'the', 'and', 'for', 'this', 'that', 'with', 'you', 'your', 'are', 'was', 'has', 'have',

  'not', 'but', 'can', 'all', 'any', 'our', 'out', 'now', 'too', 'also', 'please', 'lol',

  'from', 'into', 'just', 'like', 'more', 'some', 'than', 'then', 'them', 'they', 'what',

  'when', 'where', 'which', 'will', 'about', 'agent', 'make', 'made', 'show', 'look',

]);

const PROCESS_LABEL_CAP = 2;

const CONSTRAINT_PER_NODE_CAP = 3;

const CONSTRAINT_LIST_CAP = 10;

const CONSTRAINT_CLAUSE_MAX = 160;

const CONSTRAINT_DIRECTIVE_RE =

  /\b(?:no|don'?t|do not|never|must(?: not)?|always|only|make sure|ensure|avoid|keep it|keep the|stay|don'?t add|do not add|no longer|stop|without|not a|never use|never add)\b/i;

const CONSTRAINT_DESCRIPTIVE_RE =

  /\b(?:i (?:don'?t|do not|can'?t|cannot)\b[^.]*\b(?:see|know|understand|think|see)|do you|does this|is this|why (?:do|does|is|are)|what (?:url|do|is|are)|how (?:do|does|can)|can you|could you|would (?:fable|it)|i (?:like|agree|see|don'?t see)\b)/i;

const CONSTRAINT_NAMED = [

  { re: /\b(?:no|don'?t add|do not add|without|never add)\b[^.]{0,20}\b(?:in[\s-]?line)\s+(?:code\s+)?comments?\b/i, label: 'No inline code comments in shipped code' },

  { re: /\b(?:no|without|avoid)\b[^.]{0,30}\bem[\s-]?dash/i, label: 'No em dashes' },

  { re: /\bem[\s-]?dash(?:es)?\b[^.]{0,30}\b(?:no|avoid|never|remove|don'?t)\b/i, label: 'No em dashes' },

  { re: /\b(?:keep|stays?|still says?|must be|use)\b[^.]{0,20}\bapache\b/i, label: 'License must stay Apache' },

  { re: /\bapache\b[^.]{0,20}\b(?:licens|2\.0)\b/i, label: 'License must stay Apache' },

  { re: /\b(?:zero|no)[\s-]?(?:new\s+)?dependenc(?:y|ies)\b/i, label: 'Zero dependencies' },

  { re: /\b(?:local[\s-]?(?:first|only)|no\s+(?:network|telemetry|uploads?|cloud))\b/i, label: 'Local-only, no network or telemetry' },

  { re: /\b(?:don'?t|do not|never)\b[^.]{0,30}\b(?:expose|leak)\b/i, label: 'Do not expose or leak secrets' },

  { re: /\bnarrow(?:ing)?\b[^.]{0,30}\bnot\b[^.]{0,20}\b(?:adding|features?)\b/i, label: 'Narrow the product, do not add features' },

  { re: /\b(?:no\s+ai|ai[\s-]?(?:generated|authored|written|tell))\b/i, label: 'No AI-authorship tells' },

];

const DESTRUCTIVE_RE =

  /\b(?:messed up|screwed up|broke|broken|deleted|wiped|nuked|lost|gone|overwrote|overwritten|corrupted|trashed|removed by accident|accidentally (?:deleted|removed|overwrote|ran))\b/i;

const RECOVERY_RE =

  /\b(?:bring it back|bring them back|restore|recover|undo|revert|roll(?: |-)?back|get it back|put it back|can you (?:fix|recover|restore)|recreate)\b/i;

const APOLOGY_RE = /\b(?:i'?m sorry|im sorry|sorry|my bad|my fault|oops|whoops)\b/i;

const REMEDIATION_RE = new RegExp(`${DESTRUCTIVE_RE.source}|${RECOVERY_RE.source}`, 'i');

const FIGURATIVE_DESTRUCTIVE_RE = /\bbroke my (?:brain|heart|mind|spirit)\b|\bbroken (?:heart|record)\b|\bmind[- ]?blow/i;

const NOT_AGENT_DISCLAIMER_RE =

  /\bnot your (?:change|fault|code|edit|doing|problem)\b|\bpre-?existing\b|\bunrelated to your\b|\bnot (?:from|caused by|due to) your\b|\balready (?:broken|failing|broke) before\b|\bignore it\b/i;

const SECURITY_FILE_RE = /(?:^|[\\/])(?:\.env[^\\/]*|[^\\/]*(?:auth|session|middleware|login|signin|signup|permission|rbac|access[-_]?control|secur|crypto|jwt|oauth|passwd|password|secret|credential|token)[^\\/]*)$/i;

const SECURITY_FILE_EXCLUDE_RE = /(?:^|[\\/])(?:[^\\/]*tokens?\.[a-z]+|tokenizer[^\\/]*|[^\\/]*[-_.]?token(?:izer|s)?\.(?:tsx?|jsx?|css|scss|json|svg)|semantic[-_]?tokens?[^\\/]*|design[-_]?tokens?[^\\/]*)$/i;

export const RISKY_CMD_PARTS = [

  { name: 'rm_rf_combined', re: /\brm\s+(?:-[a-zA-Z]*\s+)*-[a-zA-Z]*(?:rf|fr)[a-zA-Z]*\b/i },

  { name: 'rm_r_then_f', re: /\brm\s+(?:-[a-zA-Z]*\s+)*-[a-zA-Z]*r[a-zA-Z]*\s+(?:-[a-zA-Z]*\s+)*-[a-zA-Z]*f[a-zA-Z]*\b/i },

  { name: 'rm_f_then_r', re: /\brm\s+(?:-[a-zA-Z]*\s+)*-[a-zA-Z]*f[a-zA-Z]*\s+(?:-[a-zA-Z]*\s+)*-[a-zA-Z]*r[a-zA-Z]*\b/i },

  { name: 'chmod_world_writable', re: /\bchmod\s+(?:-[a-zA-Z]+\s+)*0?777\b/i },

  { name: 'curl_pipe_shell', re: /(?:curl|wget)[^|\n]*\|\s*(?:sudo\s+)?(?:sh|bash|zsh|dash|ksh)\b/i },

  { name: 'shell_process_substitution', re: /\b(?:sh|bash|zsh|dash|ksh)\s+<\(\s*(?:curl|wget)\b/i },

  { name: 'no_verify', re: /--no-verify\b/i },

  { name: 'force', re: /--force(?![\w-])/i },

  { name: 'drop_table', re: /\bDROP\s+TABLE\b/i },

  { name: 'drop_schema', re: /\bDROP\s+SCHEMA\b/i },

  { name: 'truncate', re: /\bTRUNCATE\s+(?:TABLE\s+)?[\w."`]+/i },

];

const RISKY_CMD_RE = composeOr(RISKY_CMD_PARTS);

const SECRET_CONTENT_RE = /(?:\bsource\s+[^\n]*\.env\b|(?:^|[;&|]|\s)\.\s+[^\n]*\.env\b|\.env\.(?:secrets|local|prod|production)\b|\bexport\s+[A-Z0-9_]*(?:_API_KEY|_TOKEN|_SECRET|_PASSWORD|API_KEY|SECRET_KEY|ACCESS_KEY|PRIVATE_KEY)\b|\b(?:wrangler|doppler|vault)\b|\bgh\s+auth\b|\baws\s+configure\b|\bgcloud\s+auth\b|\bkubectl\s+config\s+set-credentials\b|\b(?:AKIA|ASIA|AGPA|AIDA|AROA|AIPA)[A-Z0-9]{12,}\b|\b(?:gh[opusr]|github_pat)[-_][A-Za-z0-9_]{16,}\b|\bsk-[A-Za-z0-9]{16,}\b|\bxox[baprs]-[A-Za-z0-9-]{10,}\b|\b(?:aws_secret_access_key|aws_access_key_id|api[_-]?key|secret[_-]?key|access[_-]?key|secret[_-]?access[_-]?key|private[_-]?key|client[_-]?secret|password|passwd|auth[_-]?token|access[_-]?token|bearer[_-]?token|connection[_-]?string)\b\s*[:=]\s*['"][^'"\n]{6,}['"])/i;

const ACCESS_CONTROL_CONTENT_RE = /\b(?:grant\s+(?:select|insert|update|delete|all)\b|setfacl|chmod\s+[0-7]{3,4}\b|public[- ]?read(?:-write)?\b|world[- ]?readable\b|--acl[= ]public|0\.0\.0\.0\/0|publicly[- ]?(?:readable|accessible|writable)\b|"?principal"?\s*:\s*"?\*)/i;

const ACCESS_CONTROL_WEAK_RE = /\b(?:rbac|access[-_]?control)\b/i;

const VENDOR_TOKEN_RE =

  /\bsk_live_[A-Za-z0-9]{16,}\b|\bsk-[A-Za-z0-9]{16,}\b|\b(?:AKIA|ASIA|AGPA|AIDA|AROA|AIPA)[A-Z0-9]{12,}\b|\b(?:gh[opusr]|github_pat)[-_][A-Za-z0-9_]{16,}\b|\bxox[baprs]-[A-Za-z0-9-]{10,}\b|\bAIza[A-Za-z0-9_-]{20,}\b|-----BEGIN(?:\s+[A-Z]+)?\s+PRIVATE KEY-----|"type"\s*:\s*"service_account"[\s\S]{0,400}?"private_key"\s*:/;

const SECRET_KV_RE =

  /(?:^|[^A-Za-z0-9])(?:[A-Za-z0-9-]+[_-])?(?:password|passwd|secret(?:[_-]?key)?|api[_-]?key|access[_-]?key|secret[_-]?access[_-]?key|auth[_-]?token|access[_-]?token|bearer[_-]?token|private[_-]?key|client[_-]?secret|token)\s*[:=]\s*(['"]?)([^'"\n\r]{8,})\1/i;

const SECRET_PLACEHOLDER_RE =

  /^(?:<[^>]*>|\{\{?[^}]*\}?\}|\$\{?[A-Za-z0-9_]+\}?|changeme|change_me|your[_-]?\w*|example|placeholder|redacted|todo|none|null|true|false|xxx+|\*{3,}|\.{3,}|secret|password|token|key|test|dummy|sample|foobar)$/i;

const REDACTED_SECRET_RE =

  /\[REDACTED:(?:private-key-block|aws-access-key|github-token|github-fine-grained|gitlab-token|anthropic-key|openai-key|slack-token|stripe-live-key|npm-token|tailscale-key|google-api-key|sendgrid-key|twilio-key|telegram-bot-token|discord-webhook|jwt|hex-token|wireguard-key|url-basic-auth|bearer-header|secret-assignment)\]/;

function shannonEntropy(str) {

  if (!str) return 0;

  const freq = Object.create(null);

  for (const ch of str) freq[ch] = (freq[ch] || 0) + 1;

  let h = 0;

  const n = str.length;

  for (const k in freq) {

    const p = freq[k] / n;

    h -= p * Math.log2(p);

  }

  return h;

}

function isSecretByValue(body) {

  if (typeof body !== 'string' || !body) return false;

  if (REDACTED_SECRET_RE.test(body)) return true;

  if (VENDOR_TOKEN_RE.test(body)) return true;

  const m = SECRET_KV_RE.exec(body);

  if (m) {

    const value = m[2].trim();

    if (

      value.length >= 8 &&

      !SECRET_PLACEHOLDER_RE.test(value) &&

      shannonEntropy(value) >= 2.5 &&

      /[A-Za-z]/.test(value) &&

      /[0-9!@#$%^&*\-_]/.test(value)

    ) {

      return true;

    }

  }

  return false;

}

const CONFIG_SURFACE_PATH_RE =

  /(?:^|[\\/])(?:[^\\/]*\.(?:tfvars?|env[^\\/]*)|[^\\/]*\.env|[^\\/]*configmap[^\\/]*\.ya?ml|docker-compose[^\\/]*\.ya?ml|compose[^\\/]*\.ya?ml|[^\\/]*values\.ya?ml|values-[^\\/]*\.ya?ml|[^\\/]*\.tf)$/i;

const CONFIG_KV_RE =

  /(?:^|[^A-Za-z0-9_])([A-Za-z_][A-Za-z0-9_-]*)\s*[:=]\s*(['"]?)([^'"\n\r]{12,})\2/;

const HEX_DIGEST_RE = /^[0-9a-fA-F]{32,}$/;

const B64_BLOB_RE = /^[A-Za-z0-9+/]{44,}={0,2}$/;

function isConfigSurfaceSecret(body, file) {

  if (typeof body !== 'string' || !body || !file) return false;

  const surface = classifySecuritySurface(file);

  if (!(surface === 'secrets' || surface === 'deployment' || surface === 'ci')) return false;

  if (!CONFIG_SURFACE_PATH_RE.test(file)) return false;

  const m = CONFIG_KV_RE.exec(body);

  if (!m) return false;

  const value = m[3].trim();

  if (value.length < 12) return false;

  if (SECRET_PLACEHOLDER_RE.test(value)) return false;

  if (HEX_DIGEST_RE.test(value)) return false;

  if (B64_BLOB_RE.test(value)) return false;

  if (shannonEntropy(value) < 3.0) return false;

  const hasSeparator = /[-_.:/+!@#$%^&*]/.test(value);

  const hasCaseMix = /[a-z]/.test(value) && /[A-Z]/.test(value);

  if (!hasSeparator && !hasCaseMix) return false;

  return true;

}

const PUBLIC_CIDR_RE = /\b0\.0\.0\.0\/0\b|::\/0/;

const PUBLIC_ACL_PAIR_RE =

  /\b(?:acl|visibility|public|access|principal|allow|ingress)\b\s*[:=]\s*['"]?\s*(?:\*|(?:public|anyone|everyone|allusers|allauthenticatedusers|0\.0\.0\.0)\b)/i;

const GRANT_TO_PUBLIC_RE = /\bgrant\b[^;]{0,120}?\bto\s+(?:public\b|\*)/i;

function chmodWorldExposed(body) {

  const re = /\bchmod\s+(?:-[a-zA-Z]+\s+)*0?([0-7])([0-7])([0-7])\b/gi;

  let m;

  while ((m = re.exec(body)) !== null) {

    if (Number(m[3]) >= 4) return true;

  }

  return false;

}

function isPublicExposure(body) {

  if (typeof body !== 'string' || !body) return false;

  if (PUBLIC_CIDR_RE.test(body)) return true;

  if (PUBLIC_ACL_PAIR_RE.test(body)) return true;

  if (chmodWorldExposed(body)) return true;

  if (GRANT_TO_PUBLIC_RE.test(body)) return true;

  return false;

}

const SAFETY_FLAG_OFF_RE =

  /\b(secure|http[-_]?only|verify|verify[-_]?ssl|ssl[-_]?verify|reject[-_]?unauthorized|strict|strict[-_]?ssl|csrf|csrf[-_]?protection|check[-_]?hostname|validate[-_]?certs?|tls[-_]?verify|cert[-_]?verify|require[-_]?auth|auth[-_]?required|enforce[-_]?https|signature[-_]?verification)\b\s*[:=]\s*(?:false|0|off|no|none|disabled)\b/i;

const GUARD_COMMENTED_OUT_RE =

  /(?:\/\/|#|--|<!--)\s*(?:require[-_]?auth|auth[-_]?required|check[-_]?permission|check[-_]?auth|verify[-_]?token|csrf[-_]?protect\w*|authorize|authenticate|ensure[-_]?(?:auth|admin|login)|is[-_]?authenticated|login[-_]?required|permission[-_]?required|guard|enforce[-_]?https|validate[-_]?(?:token|session|cert))\b/i;

function isSafetyGateWeakening(body) {

  if (typeof body !== 'string' || !body) return false;

  if (SAFETY_FLAG_OFF_RE.test(body)) return true;

  if (GUARD_COMMENTED_OUT_RE.test(body)) return true;

  return false;

}

const CREDENTIAL_NOUN_RE =

  /\b(?:password|passwd|bearer(?:\s+token)?|api[\s-]?key|access[\s-]?token|signing[\s-]?token|signing[\s-]?key|secret(?:\s+key)?|secrets?|credential|credentials|service[\s-]?account(?:\s+json)?|sa[\s-]?key|authorization(?:\s+header)?|auth[\s-]?token|private[\s-]?key|connection[\s-]?string|client[\s-]?secret|access[\s-]?key|token)\b/i;

const CREDENTIAL_SINK_VERB_RE =

  /\b(?:log(?:s|ged|ging)?|print(?:s|ed|ing)?|echo(?:ed|ing)?|dump(?:s|ed|ing)?|console\.log|fmt\.Print\w*|System\.out|commit(?:s|ted|ting)?|push(?:es|ed|ing)?|expose(?:s|d)?|exposing|output(?:s|ted|ting)?|writ(?:e|es|ing|ten)\s+(?:to|into)\s+(?:the\s+)?log)\b/i;

const CREDENTIAL_REMEDIATION_RE =

  /\b(?:remov(?:e|es|ed|ing)|redact(?:s|ed|ing)?|mask(?:s|ed|ing)?|scrub(?:s|bed|bing)?|rotat(?:e|es|ed|ing)|revok(?:e|es|ed|ing)|strip(?:s|ped|ping)?|sanitiz(?:e|es|ed|ing)|fingerprint|last[\s-]?four|last-?4)\b/i;

function clauseSplit(body) {

  return String(body || '').split(/[.!?;\n]+/);

}

function credentialMishandlingClause(body) {

  if (typeof body !== 'string' || !body) return null;

  for (const clause of clauseSplit(body)) {

    if (!CREDENTIAL_NOUN_RE.test(clause)) continue;

    if (!CREDENTIAL_SINK_VERB_RE.test(clause)) continue;

    if (CREDENTIAL_REMEDIATION_RE.test(clause)) continue;

    return clause.replace(/\s+/g, ' ').trim();

  }

  return null;

}

function isCredentialFile(file) {

  if (!file || !SECURITY_FILE_RE.test(file)) return false;

  if (SECURITY_FILE_EXCLUDE_RE.test(file)) return false;

  return true;

}

function securityConcernKey(secActs) {

  if (!Array.isArray(secActs) || !secActs.length) return null;

  const strong = secActs.filter((s) => s.strong);

  const pick = (list) => {

    for (const s of list) {

      const f = s.action && s.action.file;

      if (f && (isCredentialFile(f) || classifySecuritySurface(f))) return f;

    }

    return null;

  };

  const file = pick(strong) || pick(secActs);

  if (!file) return null;

  return String(file).toLowerCase().replace(/\\/g, '/').replace(/\/+/g, '/');

}

const CRED_STEM_RULES = [

  { stem: 'private-key', re: /\bprivate[\s_-]?key\b/i },

  { stem: 'signing-secret', re: /\bsigning[\s_-]?(?:secret|key)\b/i },

  { stem: 'jwt', re: /\bjwt\b/i },

  { stem: 'api-key', re: /\bapi[\s_-]?key\b/i },

  { stem: 'bearer', re: /\bbearer\b/i },

  { stem: 'password', re: /\b(?:password|passwd)\b/i },

];

function credentialStemKey(secActs) {

  if (!Array.isArray(secActs) || !secActs.length) return null;

  let text = '';

  for (const s of secActs) {

    text += ` ${s.evidence || ''}`;

    if (s.action) text += ` ${s.action.command || ''} ${s.action.input || ''}`;

  }

  if (!text.trim()) return null;

  for (const rule of CRED_STEM_RULES) {

    if (rule.re.test(text)) return rule.stem;

  }

  return null;

}

const NARRATED_SECURITY_INTENT_RE =

  /\b(?:re-?licens(?:e|ed|ing)|rewrote|rewrite|all[\s-]?rights[\s-]?reserved|proprietary[\s-]?licens\w*|strip(?:s|ped|ping)?|disabl(?:e|ed|ing)|remov(?:e|ed|ing)|delet(?:e|ed|ing)|leak(?:s|ed|ing)?|expos(?:e|ed|ing)|bypass(?:es|ed|ing)?)\b/i;

const NARRATED_SECURITY_TARGET_RE =

  /\b(?:licens\w*|authentication|authorization|auth(?:[\s-]?(?:check|flow|token|guard))|secret\w*|credential\w*|access[\s-]?control|permissions?|rbac|admin (?:schema|mutations?|routes?)|(?:unit|integration|e2e|smoke|auth)?\s*tests?\b)\b/i;

function narratedSecurityIntentClause(body) {

  if (typeof body !== 'string' || !body) return null;

  for (const clause of clauseSplit(body)) {

    if (!NARRATED_SECURITY_INTENT_RE.test(clause)) continue;

    if (!NARRATED_SECURITY_TARGET_RE.test(clause)) continue;

    if (CREDENTIAL_REMEDIATION_RE.test(clause)) continue;

    return clause.replace(/\s+/g, ' ').trim();

  }

  return null;

}

const SECURITY_CORRECTION_KINDS = new Set(['user_text_decline', 'user_declined_tool', 'user_interrupt']);

function narratedSecurityIntent(node) {

  if (!node) return null;

  for (const a of node.actions || []) {

    const clause = narratedSecurityIntentClause(String(a.narration || ''));

    if (clause) return clause;

  }

  const isUserComplaint =

    (Array.isArray(node.rejections) &&

      node.rejections.some((r) => SECURITY_CORRECTION_KINDS.has(r.kind))) ||

    hasSecurityCorrection(node.text);

  if (!isUserComplaint && typeof node.text === 'string' && node.text.length <= 1200) {

    const clause = narratedSecurityIntentClause(node.text);

    if (clause) return clause;

  }

  return null;

}

const SECURITY_SURFACE_RULES = [

  { surface: 'auth', re: /(?:^|[\\/])[^\\/]*(?:auth|login|signin|signup|session|oauth|jwt|sso|saml)[^\\/]*$/i },

  { surface: 'secrets', re: /(?:^|[\\/])(?:\.env[^\\/]*|[^\\/]*(?:secret|credential|password|passwd|apikey|api[-_]key|token)[^\\/]*)$/i },

  { surface: 'access-control', re: /(?:^|[\\/])[^\\/]*(?:rbac|permission|access[-_]?control|policy|policies|guard|middleware)[^\\/]*$/i },

  { surface: 'crypto', re: /(?:^|[\\/])[^\\/]*(?:crypto|cipher|encrypt|decrypt|hash|hmac|signature|signing)[^\\/]*$/i },

  { surface: 'dependency-config', re: /(?:^|[\\/])(?:package\.json|package-lock\.json|yarn\.lock|pnpm-lock\.yaml|requirements\.txt|pyproject\.toml|Pipfile|go\.mod|Cargo\.toml|Gemfile)$/i },

  { surface: 'ci', re: /(?:^|[\\/])(?:\.github[\\/]workflows[\\/][^\\/]+|\.gitlab-ci\.yml|\.circleci[\\/][^\\/]+|azure-pipelines\.yml|Jenkinsfile)$/i },

  { surface: 'deployment', re: /(?:^|[\\/])(?:Dockerfile|docker-compose[^\\/]*\.ya?ml|[^\\/]*\.(?:tf|tfvars)|wrangler\.toml|vercel\.json|netlify\.toml|fly\.toml|[^\\/]*deploy[^\\/]*)$/i },

  { surface: 'tests', re: /(?:^|[\\/])[^\\/]*(?:\.(?:test|spec)\.[a-z0-9]+|_test\.[a-z0-9]+|test_[^\\/]+)$|(?:^|[\\/])(?:tests?|__tests__|spec)[\\/]/i },

];

const TEST_SKIP_API_RE =

  /\b(?:test|it|describe|context|suite|t)\.(?:skip|only|todo)\b|\bx(?:it|describe|test|context)\s*\(|\bf(?:it|describe)\s*\(|@(?:Disabled|Ignore|Skip)\b|\bpytest\.mark\.skip\w*|\b(?:skip|disabl\w*|remov\w*|delet\w*|drop)\b[^.\n]{0,24}\b(?:e2e|integration|unit|smoke|auth)?\s*(?:tests?|specs?|suite)\b|\b(?:tests?|specs?|suite)\b[^.\n]{0,24}\b(?:disabl|skip|remov|delet|comment(?:ed)? out|turn(?:ed)? off)\w*|--no-tests?\b|--skip-tests?\b/i;

const TEST_SKIP_RE =

  /\b(?:disabl|skip|remov|delet|comment(?:ed)? out|drop|turn(?:ed)? off|x?(?:it|describe)\.skip|--no-tests?|--skip-tests?)\w*\b[^.\n]{0,24}\btests?\b|\btests?\b[^.\n]{0,24}\b(?:disabl|skip|remov|delet|comment(?:ed)? out|turn(?:ed)? off)\w*/i;

const SECURITY_CORRECTION_RE =

  /\b(?:don'?t|do not|never)\b[^.]{0,30}\b(?:leak|expose|commit|hardcode|hard[- ]?code|push|publish|paste|embed|inline|bake|put|write|store|save)\b[^.]{0,30}\b(?:secret|secrets|token|tokens|key|keys|credential|credentials|password|passwords|env|api)\b|\b(?:rotate|revoke|regenerate|invalidate)\b[^.]{0,25}\b(?:that|the|this|those|your|my)?\s*(?:secret|token|key|credential|password|pat|api[- ]?key|access token)\b|\bthat'?s? (?:a|the|my|our) (?:secret|credential|api[- ]?key|token|password)\b|\b(?:revert|undo|roll ?back)\b[^.]{0,25}\b(?:the|that|those)?\s*(?:auth|security|permission|access[- ]?control|rbac|credential)\b|\b(?:you|it)\b[^.]{0,20}\b(?:leaked|exposed|hardcoded|hard[- ]?coded|committed)\b[^.]{0,25}\b(?:secret|token|key|credential|password|env)\b|\b(?:don'?t|do not|never)\b[^.]{0,30}\b(?:make|leave|set|keep|expose|open)\b[^.]{0,25}\b(?:public|world[- ]?readable|publicly|wide[- ]?open|accessible to (?:everyone|all|the (?:public|world)))\b|\block (?:it|this|that|the bucket|things?) down\b/i;

function hasSecurityCorrection(text) {

  return typeof text === 'string' && text.length <= 4000 && SECURITY_CORRECTION_RE.test(text);

}

const TOOL_ACTION_REDIRECT_RE =

  /\buse\b[^.]{0,30}\b(?:the\s+)?(?:Edit|Write|Read|Bash|Glob|Grep|NotebookEdit|MultiEdit|Task|Search|Replace|Apply\s*Patch|Patch|str_replace\w*|apply_patch)\b(?:\s+(?:tool|command|function|action))?[^.]{0,40}\b(?:instead|rather than|not\b)|\b(?:instead of|rather than)\b[^.]{0,30}\buse\b[^.]{0,30}\b(?:the\s+)?(?:Edit|Write|Read|Bash|Glob|Grep|NotebookEdit|MultiEdit|Task|Search|Replace|Apply\s*Patch|Patch)\b|\bswitch to\b[^.]{0,20}\b(?:the\s+)?(?:Edit|Write|Read|Bash|Glob|Grep|NotebookEdit|MultiEdit|Task)\b(?:\s+(?:tool|command|action))?/i;

function hasToolActionRedirectRemedy(text) {

  return typeof text === 'string' && text.length <= 4000 && TOOL_ACTION_REDIRECT_RE.test(text);

}

export function classifySecuritySurface(file) {

  if (!file) return null;

  for (const rule of SECURITY_SURFACE_RULES) {

    if (rule.re.test(file)) return rule.surface;

  }

  return null;

}

export function isRiskyCommand(command) {

  return typeof command === 'string' && RISKY_CMD_RE.test(command);

}

export function mentionsTestSkip(text) {

  return (

    typeof text === 'string' &&

    text.length <= 4000 &&

    (TEST_SKIP_RE.test(text) || TEST_SKIP_API_RE.test(text))

  );

}

function securityActions(node) {

  const out = [];

  let credMishandle = null;

  for (const a of node.actions || []) {

    const scan = `${a.narration || ''} ${a.command || ''} ${a.input || ''}`;

    const clause = credentialMishandlingClause(scan);

    if (clause) { credMishandle = { action: a, clause }; break; }

  }

  if (credMishandle) {

    out.push({

      action: credMishandle.action,

      kind: 'credential-mishandling',

      strong: true,

      evidence: credMishandle.clause,

    });