Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

36.3 KB
Raw Blame
package redact

import (
	"regexp"
	"slices"
	"strings"
	"unicode"
	"unicode/utf8"
)

// A local model (internal/pii, Settings → Privacy's "Find with a local
// model") finds what no rule can: a name or an address in free text, a
// password with no password= before it. Its spans are masked beside the
// rules', under the same switches: a name, an address, a phone number, an
// email or an account number is personal data, a secret is a secret.

// Found is a span the model found in a text: byte offsets, its label,
// and how sure the model is of it (0 to 1; masking drops what is under
// the threshold the user set, internal/masking).
type Found struct {
	Start, End int
	Label      string
	Score      float64 `json:"score,omitempty"`
}

// Model finds spans in each of texts, in order. It never fails: one that
// can't find (the model didn't start) panics, so that the request is held
// back rather than sent unmasked (gwmw.Safely).
type Model func(texts []string) [][]Found

// modelKinds are the placeholders' kinds for the model's labels. Its
// private_date and private_url are left out: a date in a request is
// nearly always a log's or a version's, and a URL the agent's own.
var modelKinds = map[string]string{
	"private_person":  "PERSON",
	"private_address": "ADDRESS",
	"private_phone":   "PHONE",
	"private_email":   "EMAIL",
	"account_number":  "ACCOUNT",
	"secret":          "SECRET",
}

// modelCat is the category (Options.covers) of each kind the model finds.
func modelCat(kind string) string {
	if kind == "SECRET" {
		return ""
	}
	return catPersonal
}

// modelSpans are o.found's spans for s that o covers, trimmed of the
// spaces the model takes in with a word (and a Chinese name of what it
// ran on into, zhTrim), and with what it gets wrong often left out
// (modelTakes); and the Chinese names it missed (zhNameSpans: only
// nicknames where the model finds names itself, o.NamesByModel).
func modelSpans(s string, o Options) []span {
	if o.Model == nil || !o.covers(catPersonal) && len(o.found[s]) == 0 {
		return nil
	}
	var out []span
	for _, f := range o.found[s] {
		kind := modelKinds[f.Label]
		if kind == "" || !o.covers(modelCat(kind)) || f.Start < 0 || f.End > len(s) || f.Start >= f.End {
			continue
		}
		a, b := f.Start, f.End
		if kind == "SECRET" {
			// a JSON key the model took in with its value
			// (ledgerId":"gl_Wq7r…) is the key's, not the secret's
			if k := strings.LastIndex(s[a:b], `":"`); k >= 0 {
				a += k + 3
			}
		}
		edge := isSpace
		if kind != "SECRET" {
			edge = delimiter
		}
		for a < b && edge(s[a]) {
			a++
		}
		for b > a && edge(s[b-1]) {
			b--
		}
		if kind == "PERSON" {
			a, b = zhTrim(s, a, b)
		}
		if a < b && utf8.ValidString(s[a:b]) && modelTakes(kind, s[a:b]) && modelFits(s, a, b, kind) && !(kind == "PERSON" && zhWordNotName(s, a, b)) {
			out = append(out, span{a, b, kind, ByModel, f.Score, false})
		}
	}
	if o.covers(catPersonal) {
		var person []span
		for _, f := range out {
			if f.kind == "PERSON" {
				person = append(person, f)
			}
		}
		out = append(out, zhNameSpans(s, person, o.NamesByModel)...)
	}
	return out
}

func isSpace(c byte) bool { return c == ' ' || c == '\t' || c == '\n' || c == '\r' }

// delimiter says c may end a span of the model's and is no part of a
// name, a phone number, an address or an account: a space, or what is
// between values in JSON or a CSV row. The model's span may start at the
// token before the value, and a phone number in {"phone":"+86 139 …"}
// came as `":"+86 139 …`, or in a CSV row as `,+81 90-…`, and was no
// number to the PHONE check: it went as written (#3591). A secret's
// edges are its own (a password may start with a quote).
func delimiter(c byte) bool { return isSpace(c) || strings.IndexByte(`"',;:`, c) >= 0 }

// modelTakes says v is masked as the model's kind: a secret as long as the
// rules ask of one, never an id a vendor or a tool made (req_…, toolu_…,
// call_…), which the agent and the vendor match against another; a name
// of two letters at least, and never a snake_case word. The model took
// Codex's sequential_cutoff for a name, and a value the vendor checks
// against its own list went as a placeholder: 400 on every request until
// the local model was turned off (#3144). Such a word is a protocol's or a
// program's, wherever it is: a setting, a tool's argument, code.
func modelTakes(kind, v string) bool {
	switch kind {
	case "SECRET":
		return len(v) >= 8 && !madeID(v) && !namesThing(v) && !versionValue(v)
	case "PERSON":
		// (an ordinary Chinese word, 文案 or 关键词, is left where it is
		// read: zhWordNotName)
		return utf8.RuneCountInString(v) >= 2 && strings.IndexFunc(v, unicode.IsLetter) >= 0 && !snakeWord(v)
	case "ACCOUNT":
		return !madeID(v)
	case "EMAIL":
		// as the rule's: a file's name ([email protected]) or an example's is no
		// address, nor a host's name with no @ (eu.stg.acme.io), nor a
		// symbol (system@got, foo@@GLIBC_2.2.5): realEmail's mailHost
		return strings.Contains(v, "@") && realEmail(v)
	}
	return true
}

// snakeWord says v is ASCII letters and digits joined by underscores
// (sequential_cutoff, list_threads, mcp__codex_app).
func snakeWord(v string) bool {
	if !strings.Contains(v, "_") || strings.Trim(v, "_") == "" {
		return false
	}
	for _, c := range v {
		if !(c == '_' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9') {
			return false
		}
	}
	return true
}

// namesThing says v, which the model took for a secret, names a thing
// rather than unlocking one: a UUID (a session's, a turn's, a request's;
// window_id's has a :0 after it), a digest with its algorithm's name
// (sha256 9b74…), a file's path. The model takes all three for secrets;
// Codex's turn metadata went as {{SECRET_…}} in each id (#1977). A key or
// a password in a field named for one is still the rules' (secretNames).
func namesThing(v string) bool {
	if u, n, ok := strings.Cut(v, ":"); ok && n != "" && strings.Trim(n, digits) == "" {
		v = u
	}
	if uuidRe.MatchString(v) || digestRe.MatchString(v) || sriRe.MatchString(v) || slugRe.MatchString(v) || fileNameRe.MatchString(v) || modelName(v) {
		return true
	}
	return !strings.ContainsAny(v, " \t\n") && (strings.HasPrefix(v, "/") || strings.HasPrefix(v, "~/") ||
		strings.HasPrefix(v, "./") || strings.HasPrefix(v, "../") || len(v) > 3 && v[1] == ':' && v[2] == '\\')
}

// modelName says v is a model's or a toolchain's name: words in lower
// case joined by dashes, one of them a size (70b, 8x7b, 32k) or a date
// (20241022, 2026-09-01). The model took groqAPIModel = "llama3-70b-8192"
// and claudeAPIModel's claude-3-5-sonnet-20241022 for secrets (10-26).
// A key is written in neither case nor shape.
func modelName(v string) bool {
	if !dashedRe.MatchString(v) {
		return false
	}
	if dateIn.MatchString(v) {
		return true
	}
	for _, p := range strings.Split(v, "-") {
		if sizePartRe.MatchString(p) {
			return true
		}
	}
	return false
}

var (
	dashedRe   = regexp.MustCompile(`^[a-z][a-z0-9.]*(?:-[a-z0-9.]+)+$`)
	sizePartRe = regexp.MustCompile(`^(?:\d+x)?\d+(?:\.\d+)?[bkm]$|^20\d{6}$`)
	dateIn     = regexp.MustCompile(`(?:^|-)20\d\d-[01]\d-[0-3]\d(?:-|$)`)
)

var (
	uuidRe = regexp.MustCompile(`^(?i)[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$`)
	// a model's, a repo's or a package's name (qwen/qwen3-14b, acme/web)
	slugRe = regexp.MustCompile(`^[a-z0-9][a-z0-9._@-]*(?:/[a-z0-9._@-]+)+$`)
	// a file's name in lower case (make-icons.sh, run_all.py)
	fileNameRe = regexp.MustCompile(`^[a-z0-9][a-z0-9_-]*(?:\.[a-z0-9_-]+)*\.[a-z][a-z0-9]{0,4}$`)
	digestRe   = regexp.MustCompile(`^(?i)(?:md5|sha-?(?:1|224|256|384|512)|blake2b?|blake3)[ :=-]+[0-9a-f]{32,128}$`)
	// a package's digest as a lock file pins it (Subresource Integrity:
	// package-lock.json's and pnpm-lock.yaml's "integrity"), sha512- and
	// the hash in base64, with the } or quote the model took in after it.
	// Privacy Filter took each one for a secret.
	sriRe = regexp.MustCompile(`^sha(?:256|384|512)-[A-Za-z0-9+/]{43,86}={0,2}[}"',;)\]]*$`)
)

// madeID says v is an id of the shape vendors and tools give theirs: a
// short lower-case prefix, an underscore, then letters and digits
// (req_011CS…, toolu_01A…, call_x9…, msg_…), or more words and a nanoid's
// - and _ (req_gateway_7c41…, tb_Ra4Kp9-ZqT2_…). Stripe's keys have that
// shape too (sk_live_…, rk_test_…): one is no id.
func madeID(v string) bool {
	p, rest, ok := strings.Cut(v, "_")
	if !ok || len(p) < 2 || len(p) > 8 || len(rest) < 8 {
		return false
	}
	for _, c := range p {
		if c < 'a' || c > 'z' {
			return false
		}
	}
	plain := true
	for _, c := range rest {
		if c == '_' || c == '-' {
			plain = false
		} else if !(c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9') {
			return false
		}
	}
	return plain || !keyHeads[p]
}

// keyHeads are the prefixes of keys written as an id is (sk_live_…,
// whsec_…, shpat_…).
var keyHeads = map[string]bool{"sk": true, "rk": true, "pk": true, "whsec": true, "shpat": true, "shpss": true, "xoxb": true, "xoxp": true}

// withModel is o with what o.Model finds in texts, the texts that may be
// masked: each once, the short ones left out.
func withModel(o Options, texts []string) Options {
	if o.Model == nil || !o.Secrets && !o.Personal {
		return o
	}
	var ask []string
	seen := map[string]bool{}
	for _, t := range texts {
		if len(t) >= 3 && !seen[t] {
			seen[t] = true
			ask = append(ask, t)
		}
	}
	if len(ask) == 0 {
		return o
	}
	got := o.Model(ask)
	o.found = make(map[string][]Found, len(ask))
	for i, t := range ask {
		if i < len(got) && len(got[i]) > 0 {
			o.found[t] = got[i]
		}
	}
	return o
}

// modelFits says the model's value at s[a:b] is what its kind says by
// where it is, as modelTakes does by what it is. Run on what agents send
// (3 MB of Claude Code's requests, 10-25), the model masked ~1,800
// values where the rules masked 17, most of them wrongly: the count in
// each turn's <total_tokens>14983666 tokens left</total_tokens> as an
// account, a run's id as a phone, "Claude" and "Opus 5.5" in the system
// prompt as people, /Users/yetone's folder as a person, the tail of
// toolu_01… and req_011C… as a name or a secret, a grep pattern as a
// secret. Each goes as written now:
//   - a piece cut out of a longer word, whatever its kind;
//   - a name with a digit, a slash, an @ or a file's dot in it, all in
//     lower case (magpie, claude-in-chrome), a path's part, or an
//     assistant's or a model's own (Claude, Codex, Haiku 4.5);
//   - an account that is a commit's hash, a version, or a number with
//     nothing before it to say it is an account's; a phone number that is
//     digits only with nothing to say it is one, and no 0 or + to start,
//     or a Unix time whatever is before it;
//   - a secret that is a pattern's words, a|b|c, holds a UUID (a session's
//     file) or is a piece of JSON;
//   - an account or a phone number that is a size (1624x1487), drawing
//     data (an SVG path's M16 0H44…) or a diff's index line; a phone with
//     fewer than 7 digits, an address with no letter.
//
// Run on 22 more Claude Code sessions after a reporter on X found "95%"
// of the model's finds wrong (10-26), it still took 69 values the rules
// didn't, ~55 of them wrongly, and these go as written now too:
//   - a decimal (a metric's 104.21875033916251) or "run 48213097715" as a
//     phone;
//   - as a secret: a value right after an id's name (with ID: kq3m8zx2t,
//     <task-id>…, "backgroundTaskId":"…"), a model's or a repo's name
//     (qwen/qwen3-14b), a file's (make-icons.sh), a grep's regexp
//     (a\b\|b), a time in words (release about 17:05Z), and a hex run
//     whose key cue is further back than "key:" or "token is" (env -u
//     GH_TOKEN gh run view 48213097715);
//   - a path as an address, a host's name with no @ as an email;
//   - as a name, an acronym (CI), a product in camel case (CodeRabbit) and
//     a word the text also has as a host's name (Greptile, app.greptile.com).
//
// A name's words each start with a capital, but for the particles names
// have (van, de, bin): "local LLM", "User yetone" and claudeKeychain are
// a program's or a log's words.
func modelFits(s string, a, b int, kind string) bool {
	if a > 0 && wordByte(s[a-1]) && wordByte(s[a]) || b < len(s) && wordByte(s[b-1]) && wordByte(s[b]) {
		return false
	}
	v := s[a:b]
	if evmRe.MatchString(v) {
		// a wallet's or a contract's address (0x and 40 hex digits) is
		// public, on its chain for anyone to read, and the vendor's model
		// needs it as written: masked, it took the placeholder for a
		// private key and told the user to rotate it (0x0_air on X,
		// 10-28). A key is 64 hex digits; one called a key is masked still.
		return kind == "SECRET" && secretCued(s, a)
	}
	if packageAt(s, a, b) {
		return false
	}
	switch kind {
	case "PERSON":
		return personFits(s, a, b, v)
	case "ACCOUNT":
		if hexRe.MatchString(v) && strings.ContainsAny(v, "abcdef") || versionRe.MatchString(v) || !numberLike(v) {
			return false
		}
		return strings.Trim(v, digits) != "" || cued(s, a, accountCues)
	case "PHONE":
		if !numberLike(v) || countDigits(v) < 7 || epochNumber(v) || decimalRe.MatchString(v) || unicode.IsLetter(rune(v[0])) {
			return false
		}
		return strings.Trim(v, digits) != "" || v[0] == '0' || cued(s, a, phoneCues)
	case "ADDRESS":
		// a path is no address (-Users-x-projects-a/2b1a….jsonl); a Chinese
		// one has no spaces, a Latin one has them
		if isASCII(v) && !strings.ContainsAny(v, " \t\n") && strings.ContainsAny(v, `/\`) || programWords(v) {
			return false
		}
		return strings.IndexFunc(v, unicode.IsLetter) >= 0
	case "SECRET":
		if !wordByte(v[0]) || patternWords(v) || regexpLike(v) || idAfter(s, a) || strings.ContainsRune(v, ' ') && clockIn.MatchString(v) || uuidIn.MatchString(v) || strings.Contains(v, `": `) || strings.Contains(v, `", "`) || linkRe.MatchString(v) {
			return false
		}
		// a piece of a longer base64 run (an image, a signature) is cut
		// from it at a '+' or '/'
		if a > 1 && (s[a-1] == '+' || s[a-1] == '/') && wordByte(s[a-2]) || b+1 < len(s) && (s[b] == '+' || s[b] == '/') && wordByte(s[b+1]) {
			return false
		}
		// a bare hex run is a hash or an id unless something calls it a key;
		// one with words after it is a hash in a tool's output
		if f := strings.Fields(v); len(f) > 1 && hexRe.MatchString(f[0]) || modCacheRe.MatchString(v) {
			return false
		}
		if pinnedAfter(s, b) {
			return false
		}
		if wordsOnly(v) && !assignedSecret(s, a) {
			return false
		}
		return !hexRe.MatchString(v) || secretCued(s, a)
	case "EMAIL":
		// a URL's user:password@host is no address, as for the rule's (#3538)
		return wordByte(v[0]) && !modCacheRe.MatchString(v) && !inUserinfo(s, a)
	}
	return true
}

// programWords says v, which the model took for a person's or a place's,
// is a program's words: it has an underscore (node_modules, __pycache__,
// node_modules 太, the model running on into the sentence after it), or
// it is Latin letters in lower case with no digit (dist, vendor,
// site-packages, ls node_modules). No name and no address is written so:
// a name has its capitals (personFits), an address its number or its
// capitals (42 Wallaby Way), a Chinese one its characters. The model took
// such a folder for personal data and the agent read a placeholder where
// the folder was ("node_modules给识别成姓名了", kekek711 on X, 10-29).
func programWords(v string) bool {
	if strings.Contains(v, "_") {
		return true
	}
	return isASCII(v) && strings.IndexFunc(v, unicode.IsLetter) >= 0 && strings.IndexFunc(v, func(r rune) bool { return unicode.IsUpper(r) || unicode.IsDigit(r) }) < 0
}

// wordsOnlyRe is words in lower case and nothing else, joined by - . or
// _: drizzle-orm, reflect-metadata, lodash.merge, secretstorage; and a
// folder's name as a path or Python writes it, with the slash after it
// or underscores around it: node_modules/, __pycache__.
var wordsOnlyRe = regexp.MustCompile(`^_*[a-z]+(?:[-._][a-z]+)*_*/?$`)

// wordsOnly says v, which the model took for a secret, is made of words
// in lower case alone, as a package's, a tool's or a setting's name is.
// A key is random: it has a digit, a capital or a symbol in it, and the
// SECRET rules ask a digit of a value after password= too (secretValue).
// AstrLink Guard took drizzle-orm for a secret in a tsup config's
// external list in a Markdown fence (dniray on Discord, v0.1.1976; 0.515
// on that line alone), after v0.1.1932 and v0.1.1976 had each let it go
// in more places (an import, package.json, a tsc error): the places a
// package's name is written can't all be listed, so the shape decides. Such a value is a
// secret only where it is assigned to a secret's name (assignedSecret):
// PASSWORD=opensesame, "password": "letmeinplease", the wifi password is
// purplemonkey.
func wordsOnly(v string) bool { return wordsOnlyRe.MatchString(v) }

// assignedSecret says the value at s[a] is given to a secret's name: the
// name, then =, :, is or 是 (and the quotes around them), right before it.
// A list's comma before it is no assignment, whatever is further back:
// 'jsonwebtoken', 'drizzle-orm' (secretCued takes the token in that).
func assignedSecret(s string, a int) bool {
	before := strings.ToLower(strings.TrimRight(s[max(0, a-64):a], " \t\"'`“「"))
	for _, sep := range []string{"=", ":", ":", " is", " was", "是", "为", "為"} {
		if !strings.HasSuffix(before, sep) {
			continue
		}
		name := strings.TrimRight(before[:len(before)-len(sep)], " \t\"'`:")
		i := len(name)
		for i > 0 && (wordByte(name[i-1]) || name[i-1] == '.' || name[i-1] == '-') {
			i--
		}
		if i == len(name) {
			// a Chinese name: 密码是, 令牌为
			return slices.ContainsFunc(secretCues, func(c string) bool { return c[0] >= 0x80 && strings.HasSuffix(name, c) })
		}
		return slices.ContainsFunc(secretCues, func(c string) bool { return c[0] < 0x80 && strings.Contains(name[i:], c) }) ||
			strings.Contains(name[i:], "pass") || strings.Contains(name[i:], "pwd") || strings.Contains(name[i:], "credential")
	}
	return false
}

// pinnedAfter says the value that ends at s[b] is a package's name, as
// a requirement pins its version after it: django-rest-passwordreset==1.4.0,
// tokenizers>=0.15, a-lib~=2.1 (pip's comparisons). AstrLink Guard took a
// package with password in its name for a secret, and the agent read
// {{SECRET_…}}==1.4.0 in requirements.txt (dniray on Discord, v0.1.1917).
// No secret has a version pinned after it; a password before @ and an
// address ([email protected]) is no pin.
func pinnedAfter(s string, b int) bool {
	rest := s[b:]
	for _, op := range []string{"===", "==", ">=", "<=", "~=", "!="} {
		if strings.HasPrefix(rest, op) {
			rest = strings.TrimLeft(rest[len(op):], " ")
			return rest != "" && rest[0] >= '0' && rest[0] <= '9'
		}
	}
	return false
}

// moduleRe is what code names a module by: drizzle-orm, @scope/name/sub,
// node:fs, ./db/schema, golang.org/x/net, serde_json::Value.
var moduleRe = regexp.MustCompile(`^(?:[a-z]+:)?@?[A-Za-z0-9_.~-]+(?:(?:/|::)[A-Za-z0-9_.~@-]+)*$`)

// moduleAt says s[a:b] is the module a line of code loads: import { eq }
// from 'drizzle-orm', require(' jsonwebtoken '), import('x'), from
// django.contrib import auth, import torch, use jsonwebtoken::encode.
// AstrLink Guard took a package with a word like token in its name, or
// one alone in its quotes, for a secret (dniray on Discord, v0.1.1917:
// from ' {{SECRET_…}} '), and the agent read an import it could not
// resolve. A secret is never the module code loads. Prose is not code:
// "the token from 'a1b2…'" and "copy it from a1b2…" are judged as before,
// as a from counts only on an import or export line or after } or *.
func moduleAt(s string, a, b int) bool {
	if !moduleRe.MatchString(s[a:b]) {
		return false
	}
	line := strings.LastIndexByte(s[:a], '\n') + 1
	head := codeHead(s[line:a])
	end := strings.IndexByte(s[b:], '\n')
	if end < 0 {
		end = len(s) - b
	}
	tail := strings.TrimLeft(s[b:b+end], " \t")
	if q := strings.TrimRight(head, " \t"); q != "" && strings.ContainsRune("'\"`", rune(q[len(q)-1])) {
		// quoted, and ended in the same quote: from ' drizzle-orm '
		if tail == "" || tail[0] != q[len(q)-1] {
			return false
		}
		q = strings.TrimRight(q[:len(q)-1], " \t")
		if c := strings.TrimSuffix(q, "("); c != q {
			q = strings.TrimRight(c, " \t")
			return wordEnd(q, "require") || wordEnd(q, "import")
		}
		if !wordEnd(q, "from") {
			// import 'reflect-metadata'
			return q == "import"
		}
		q = strings.TrimRight(strings.TrimSuffix(q, "from"), " \t")
		return strings.HasPrefix(q, "import") || strings.HasPrefix(q, "export") ||
			strings.HasSuffix(q, "}") || strings.HasSuffix(q, "*") || q == ""
	}
	// unquoted, the word starts the line: Python's and Rust's
	switch strings.TrimRight(head, " \t") {
	case "from":
		return strings.HasPrefix(tail, "import ")
	case "import":
		return tail == "" || tail[0] == ',' || tail[0] == ';' || strings.HasPrefix(tail, "as ")
	case "use", "extern crate":
		return strings.HasPrefix(tail, "::") || tail == "" || tail[0] == ';' || tail[0] == '{'
	}
	return false
}

// codeHead is a line of code up to a value, without what a tool puts
// before the code: an editor's or cat -n's line number (Claude Code's
// Read gives "     1→import drizzle from 'drizzle-orm'", cat -n a tab,
// grep -n a colon) and a diff's + or -. With the number before it, a
// default import was no import line (dniray, v0.1.1965).
func codeHead(h string) string {
	h = strings.TrimLeft(h, " \t")
	i := 0
	for i < len(h) && h[i] >= '0' && h[i] <= '9' {
		i++
	}
	if i > 0 {
		for _, sep := range []string{"→", "\t", ":", "|"} {
			if strings.HasPrefix(h[i:], sep) {
				h = strings.TrimLeft(h[i+len(sep):], " \t")
				break
			}
		}
	}
	if h != "" && (h[0] == '+' || h[0] == '-') {
		h = strings.TrimLeft(h[1:], " \t")
	}
	return h
}

// packageAt says s[a:b] is a package's or a module's name by where it is:
// the module code loads (moduleAt), a dependency a manifest pins
// (dependencyAt), a folder under node_modules or site-packages, the
// module an error could not find (missingModuleAt), a package an install
// names (installedAt) or one pinned at its version with @
// ([email protected], pinnedAt). The local model took drizzle-orm for a
// secret in package.json, a tsc error or a sentence; masked there, the
// name was known (knownSpans) and masked on the import line too, which
// moduleAt had let go when the model found it there (dniray on Discord,
// v0.1.1965: from ' {{SECRET_o2tu7vej}} ' still). knownSpans asks this
// too: no secret is a name code loads or a manifest pins, whatever
// found it before.
func packageAt(s string, a, b int) bool {
	// the whole of a name a piece of it was found in: drizzle-orm of
	// drizzle-orm/pg-core, name of @scope/name
	for b+1 < len(s) && s[b] == '/' && moduleByte(s[b+1]) {
		for b++; b < len(s) && moduleByte(s[b]); b++ {
		}
	}
	if a > 2 && s[a-1] == '/' {
		i := a - 1
		for i > 0 && moduleByte(s[i-1]) {
			i--
		}
		if i < a-2 && s[i] == '@' {
			a = i
		}
	}
	if !moduleRe.MatchString(s[a:b]) {
		return false
	}
	return moduleAt(s, a, b) || dependencyAt(s, a, b) || underPackages(s, a) ||
		missingModuleAt(s, a, b) || installedAt(s, a, b) || pinnedAt(s, a, b)
}

func moduleByte(c byte) bool { return wordByte(c) || c == '.' || c == '-' || c == '~' || c == '@' }

// dependencyAt says s[a:b] is a dependency's name as a manifest pins it:
// a JSON key whose value is a version or a range ("drizzle-orm":
// "^0.36.4", "x": "workspace:*") or TOML's at a line's start (jsonwebtoken
// = "9.2.0"). A key whose value is no version ({"Zq8v…": "hunter2"}) is
// judged as before.
func dependencyAt(s string, a, b int) bool {
	rest := ""
	if a > 0 && s[a-1] == '"' && b < len(s) && s[b] == '"' {
		rest = strings.TrimLeft(s[b+1:], " \t")
		if !strings.HasPrefix(rest, ":") {
			return false
		}
		rest = strings.TrimLeft(rest[1:], " \t")
	} else {
		line := strings.LastIndexByte(s[:a], '\n') + 1
		if strings.Trim(s[line:a], " \t") != "" {
			return false
		}
		rest = strings.TrimLeft(s[b:], " \t")
		if !strings.HasPrefix(rest, "=") || strings.HasPrefix(rest, "==") {
			return false
		}
		rest = strings.TrimLeft(rest[1:], " \t")
		if strings.HasPrefix(rest, "{") {
			// jsonwebtoken = { version = "9", features = […] }
			return strings.HasPrefix(strings.TrimLeft(rest[1:], " \t"), "version")
		}
	}
	if !strings.HasPrefix(rest, `"`) {
		return false
	}
	v, _, ok := strings.Cut(rest[1:], `"`)
	return ok && depVersion(v)
}

// depVersion says v is what a manifest pins a dependency at: a version
// or a range of them (^0.36.4, >=0.30.0 <1, 9, 1.x, *), a workspace's or
// a catalog's, a tag (latest, next), or where it comes from (npm:,
// file:, link:, git+…, github:).
func depVersion(v string) bool {
	for _, p := range []string{"workspace:", "catalog:", "npm:", "file:", "link:", "portal:", "git+", "git:", "github:", "http://", "https://"} {
		if strings.HasPrefix(v, p) {
			return true
		}
	}
	switch v {
	case "*", "latest", "next", "beta", "canary", "x":
		return true
	}
	for _, part := range strings.Fields(strings.NewReplacer("||", " ", " - ", " ").Replace(v)) {
		if !depRangeRe.MatchString(part) {
			return false
		}
	}
	return v != ""
}

var depRangeRe = regexp.MustCompile(`^(?:[~^]|[<>]=?|=)?[vV]?\d+(?:\.(?:\d+|[xX*]))*(?:[-+][0-9A-Za-z.-]+)?$`)

// underPackages says the name at a is a folder packages are installed in:
// node_modules/drizzle-orm/…, site-packages/secretstorage/….
func underPackages(s string, a int) bool {
	return strings.HasSuffix(s[:a], "node_modules/") || strings.HasSuffix(s[:a], "node_modules\\") ||
		strings.HasSuffix(s[:a], "site-packages/") || strings.HasSuffix(s[:a], "site-packages\\")
}

// missingModuleAt says s[a:b] is quoted after the words an error names a
// module it could not load with: tsc's and Node's Cannot find module
// 'x', Python's No module named 'x', a bundler's Can't resolve 'x'.
func missingModuleAt(s string, a, b int) bool {
	if a == 0 || b >= len(s) || !strings.ContainsRune("'\"`", rune(s[a-1])) || s[b] != s[a-1] {
		return false
	}
	q := strings.ToLower(strings.TrimRight(s[:a-1], " \t"))
	for _, w := range []string{"find module", "find package", "module named", "resolve", "resolve import", "resolve module"} {
		if wordEnd(q, w) {
			return true
		}
	}
	return false
}

// installRe is a package manager's command that names packages after it.
var installRe = regexp.MustCompile(`(?:^|[\s;&|(` + "`" + `$])(?:npm|pnpm|yarn|bun|npx|pip|pip3|uv|poetry|pipx|cargo|gem|composer|deno|go)(?: +(?:pip|-[\w-]+))* +(?:add|install|i|remove|rm|uninstall|un|get|require|update|upgrade|up)(?: |$)`)

// installedAt says s[a:b] is one of the packages a command on its line
// installs or removes: pnpm add drizzle-orm postgres, npm i -D x,
// pip install a-lib. A value after a flag for a credential (--token,
// --auth) is that flag's, and judged as before.
func installedAt(s string, a, b int) bool {
	if b < len(s) && !isSpace(s[b]) && s[b] != ';' && s[b] != '&' && s[b] != '|' && s[b] != ')' {
		return false
	}
	line := strings.LastIndexByte(s[:a], '\n') + 1
	ms := installRe.FindAllStringIndex(s[line:a], -1)
	if len(ms) == 0 {
		return false
	}
	args := strings.Fields(s[line+ms[len(ms)-1][1] : a])
	if a > 0 && !isSpace(s[a-1]) {
		return false
	}
	for _, w := range args {
		if strings.ContainsAny(w, ";&|<>`$") {
			return false
		}
	}
	if n := len(args); n > 0 && strings.HasPrefix(args[n-1], "-") && credFlag(args[n-1]) {
		return false
	}
	return true
}

// credFlag says a command's flag names a credential (--token, --auth-key).
func credFlag(f string) bool {
	f = strings.ToLower(f)
	for _, w := range []string{"token", "key", "pass", "secret", "auth", "cred"} {
		if strings.Contains(f, w) {
			return true
		}
	}
	return false
}

// pinnedAt says s[a:b] is a package's name pinned at a version with @, as
// npm and pnpm write one ([email protected], [email protected]:): a name
// in lower case, as npm's are, and a version of three numbers that is no
// IPv4 address, so [email protected] is a password still.
func pinnedAt(s string, a, b int) bool {
	if b >= len(s) || s[b] != '@' || strings.ToLower(s[a:b]) != s[a:b] {
		return false
	}
	m := pinVersionRe.FindString(s[b+1:])
	return m != "" && !(len(s) > b+1+len(m) && s[b+1+len(m)] == '.')
}

var pinVersionRe = regexp.MustCompile(`^[\^~]?v?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]*[0-9A-Za-z])?`)

// wordEnd says s ends in the word w.
func wordEnd(s, w string) bool {
	return strings.HasSuffix(s, w) && (len(s) == len(w) || !wordByte(s[len(s)-len(w)-1]))
}

func wordByte(c byte) bool {
	return c == '_' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9'
}

func personFits(s string, a, b int, v string) bool {
	if strings.ContainsAny(v, "0123456789/\\@<>|=_") || strings.IndexFunc(v, unicode.IsUpper) < 0 && isASCII(v) {
		return false
	}
	// a file's name: LESSONS.md, a dot with a letter right after it
	for i := 0; i+1 < len(v); i++ {
		if v[i] == '.' && (v[i+1] >= 'a' && v[i+1] <= 'z' || v[i+1] >= 'A' && v[i+1] <= 'Z') {
			return false
		}
	}
	// a path's part: /Users/yetone, ~/.orca/
	if a > 0 && (s[a-1] == '/' || s[a-1] == '\\' || s[a-1] == '.' && a > 1 && (s[a-2] == '/' || s[a-2] == '\\')) || b < len(s) && (s[b] == '/' || s[b] == '\\') {
		return false
	}
	if strings.ContainsRune(v, ':') {
		return false
	}
	// an acronym (CI, API), a product's name in camel case (CodeRabbit,
	// OpenAI) and a site's (Greptile beside app.greptile.com) are no one's
	if w := strings.Fields(v); len(w) == 1 && (strings.Trim(v, "ABCDEFGHIJKLMNOPQRSTUVWXYZ") == "" || camelProduct(v) || hostIn(s, v)) {
		return false
	}
	for i, w := range strings.Fields(v) {
		if c := w[0]; c >= 'a' && c <= 'z' && (i == 0 || !nameParticles[w]) {
			return false
		}
		if assistantNames[strings.ToLower(w)] {
			return false
		}
	}
	return true
}

// camelProduct says v has a capital after three lower-case letters at
// least, as products are written (CodeRabbit, OpenAI) and names are not
// (McDonald, DeAndre, MacKenzie).
func camelProduct(v string) bool {
	lower := 0
	for i := 0; i < len(v); i++ {
		switch c := v[i]; {
		case c >= 'a' && c <= 'z':
			lower++
		case c >= 'A' && c <= 'Z':
			if lower >= 3 {
				return true
			}
			lower = 0
		default:
			lower = 0
		}
	}
	return false
}

// hostIn says s has the word w, in any case, as a host's name: a domain's
// first part or one after a dot (greptile.com, app.greptile.com), never
// an address's (matt.lee@…).
func hostIn(s, w string) bool {
	ls, lw := strings.ToLower(s), strings.ToLower(w)
	for i := 0; ; {
		k := strings.Index(ls[i:], lw+".")
		if k < 0 {
			return false
		}
		k += i
		i = k + 1
		if k > 0 && !strings.ContainsRune("/.@ \t\n\"'(`", rune(ls[k-1])) {
			continue
		}
		if m := hostTail.FindString(ls[k+len(lw):]); m != "" {
			return true
		}
	}
}

// hostTail is a domain's rest after its first part: .com, .greptile.com,
// ending where the host does (not at an @ or more of a word)
var hostTail = regexp.MustCompile(`^(?:\.[a-z0-9-]+)*\.[a-z]{2,6}(?:[/:\s"'),\x60]|$)`)

// nameParticles are the words in lower case a name may have between its
// others: Ludwig van Beethoven, Ibn al Haytham.
var nameParticles = map[string]bool{
	"van": true, "von": true, "der": true, "den": true, "de": true, "da": true, "del": true, "della": true,
	"di": true, "du": true, "la": true, "le": true, "bin": true, "binti": true, "al": true, "el": true,
	"y": true, "dos": true, "das": true, "do": true, "ter": true, "ten": true, "zu": true,
}

// numberLike says v is written as a number is: digits, and the spaces,
// dashes, dots, brackets and + that group them, with a letter or two at
// most (an IBAN's, ext.). A size is no number (1624x1487).
func numberLike(v string) bool {
	if sizeRe.MatchString(v) || strings.Contains(v, "..") {
		return false
	}
	letters := 0
	for _, c := range v {
		switch {
		case c >= '0' && c <= '9', strings.ContainsRune(" -.()+/", c):
		case unicode.IsLetter(c):
			letters++
		default:
			return false
		}
	}
	return letters <= 4 && countDigits(v)*2 > len(v)
}

// epochNumber says v is a Unix time, as a log or a tool's JSON has one:
// ten digits, or thirteen in milliseconds, and nothing else, starting with
// 1. The model took "timestamp": 1792903687 for a phone, with "tool_call"
// before it as the cue (#3577). No phone is written so: a North American
// number's area code starts with 2 to 9, and a Chinese mobile has eleven
// digits (the PHONE rule's).
func epochNumber(v string) bool {
	if len(v) != 10 && len(v) != 13 || v[0] != '1' {
		return false
	}
	return strings.Trim(v, digits) == ""
}

func countDigits(v string) int {
	n := 0
	for i := 0; i < len(v); i++ {
		if v[i] >= '0' && v[i] <= '9' {
			n++
		}
	}
	return n
}

func isASCII(v string) bool {
	for i := 0; i < len(v); i++ {
		if v[i] >= utf8.RuneSelf {
			return false
		}
	}
	return true
}

// assistantNames are what agents and models call themselves, in every
// system prompt: the model takes each for a person's name.
var assistantNames = map[string]bool{
	"claude": true, "chatgpt": true, "gpt": true, "codex": true, "gemini": true, "copilot": true,
	"grok": true, "kimi": true, "qwen": true, "deepseek": true, "cursor": true, "devin": true,
	"kiro": true, "opencode": true, "opus": true, "sonnet": true, "haiku": true, "fable": true,
	"glm": true, "doubao": true, "magpie": true, "jev": true,
}

var (
	hexRe = regexp.MustCompile(`^[0-9a-f]{7,64}$`)
	// an EVM chain's address: 0x and 40 hex digits, in either case or
	// mixed (EIP-55's checksum)
	evmRe     = regexp.MustCompile(`^0[xX][0-9a-fA-F]{40}$`)
	decimalRe = regexp.MustCompile(`^\d+\.\d+$`)
	// a time of day in words the model took for a passphrase (release
	// about 17:05Z)
	clockIn   = regexp.MustCompile(`(?:^|\s)\d{1,2}:\d{2}(?::\d{2})?Z?(?:\s|$)`)
	versionRe = regexp.MustCompile(`^v?\d+(?:\.\d+)+$`)
	sizeRe    = regexp.MustCompile(`^\d+ ?[x×] ?\d+$`)
	uuidIn    = regexp.MustCompile(`(?i)[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}`)
	// a name in Go's module cache (d6426ecaaf0a28de@v31)
	modCacheRe = regexp.MustCompile(`^[0-9a-f]{16}@v\d+$`)
	// a link, or a host's name with a path (discord.gg/…)
	linkRe = regexp.MustCompile(`^(?:[a-z][a-z0-9+.-]*://|[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+/)`)
)

var (
	accountCues = []string{"account", "acct", "a/c", "iban", "routing", "sort code", "card", "账号", "帐号", "账户", "帐户", "卡号", "户名"}
	secretCues  = []string{"key", "token", "secret", "password", "passwd", "密钥", "密码", "令牌"}
	phoneCues   = []string{"phone", "tel", "mobile", "cell", "call", "whatsapp", "sms", "电话", "手机", "联系", "致电"}
)

// cued says one of cues is in the 40 bytes before at, in any case.
func cued(s string, at int, cues []string) bool {
	before := strings.ToLower(s[max(0, at-40):at])
	for _, c := range cues {
		if strings.Contains(before, c) {
			return true
		}
	}
	return false
}

// regexpLike says v is a regexp's: grep's \| between alternatives, or a
// \b word boundary (qwen3-max\b\|qwen/qwen3).
func regexpLike(v string) bool {
	return strings.Contains(v, `\|`) || strings.Contains(v, `\b`)
}

// idAfter says the value at s[a:] is right after the word id, as a
// tool's output names a task's or a job's (with ID: kq3m8zx2t, (ID:
// bv7n2wq5p), <task-id>…, "backgroundTaskId":"…", "org_id": "…"): an id
// is no secret.
func idAfter(s string, a int) bool {
	t := strings.TrimRight(s[max(0, a-24):a], " :=#(>\"'`")
	n := len(t)
	if n < 2 || !strings.EqualFold(t[n-2:], "id") {
		return false
	}
	return n == 2 || !unicode.IsLetter(rune(t[n-3])) || t[n-2] == 'I' && t[n-1] == 'd'
}

// secretCued says a hex run at s[at:] is called a key, a token or a
// password: one of secretCues is right before it, with the cue's own word
// and an is, a colon or an = between (api key: 9f2c…, token is 9f2c…). A
// cue further back is about something else: GH_TOKEN in "env -u GH_TOKEN
// gh run view 48213097715" is not the run's.
func secretCued(s string, at int) bool {
	before := strings.ToLower(s[max(0, at-40):at])
	for _, c := range secretCues {
		k := strings.LastIndex(before, c)
		if k < 0 {
			continue
		}
		gap := strings.TrimLeftFunc(before[k+len(c):], func(r rune) bool { return r == '_' || unicode.IsLetter(r) || unicode.IsDigit(r) })
		words := strings.FieldsFunc(gap, func(r rune) bool { return !unicode.IsLetter(r) && !unicode.IsDigit(r) })
		if len(words) == 0 || len(words) == 1 && (words[0] == "is" || words[0] == "was" || words[0] == "是" || words[0] == "为") {
			return true
		}
	}
	return false
}

// patternWords says v is three or more words joined by |, as a grep's or
// a regexp's alternatives are.
func patternWords(v string) bool {
	parts := strings.Split(v, "|")
	if len(parts) < 3 {
		return false
	}
	for _, p := range parts {
		if p == "" || strings.IndexFunc(p, unicode.IsLetter) < 0 || strings.Trim(p, alnum+"_.-") != "" {
			return false
		}
	}
	return true
}