Skip to content

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

redact: what the local model misreads in agent requests is not masked

yetone611b9e173143
diff --git a/internal/redact/model.go b/internal/redact/model.go
index 3791da248..3ff337737 100644
--- a/internal/redact/model.go
+++ b/internal/redact/model.go
@@ -68,7 +68,7 @@ func modelSpans(s string, o Options) []span {
if kind == "PERSON" {
a, b = zhTrim(s, a, b)
}
- if a < b && utf8.ValidString(s[a:b]) && modelTakes(kind, s[a:b]) {
+ if a < b && utf8.ValidString(s[a:b]) && modelTakes(kind, s[a:b]) && modelFits(s, a, b, kind) {
out = append(out, span{a, b, kind, ByModel})
}
}
@@ -150,7 +150,7 @@ var (
// (req_011CS…, toolu_01A…, call_x9…, msg_…).
func madeID(v string) bool {
p, rest, ok := strings.Cut(v, "_")
- if !ok || len(p) < 2 || len(p) > 6 || len(rest) < 8 {
+ if !ok || len(p) < 2 || len(p) > 8 || len(rest) < 8 {
return false
}
for _, c := range p {
@@ -192,3 +192,200 @@ func withModel(o Options, texts []string) Options {
}
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;
+// - 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.
+//
+// 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]
+ 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 {
+ return false
+ }
+ return strings.Trim(v, digits) != "" || v[0] == '0' || cued(s, a, phoneCues)
+ case "ADDRESS":
+ return strings.IndexFunc(v, unicode.IsLetter) >= 0
+ case "SECRET":
+ if !wordByte(v[0]) || patternWords(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
+ }
+ return !hexRe.MatchString(v) || cued(s, a, secretCues)
+ case "EMAIL":
+ return wordByte(v[0]) && !modCacheRe.MatchString(v)
+ }
+ return true
+}
+
+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
+ }
+ 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
+}
+
+// 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)
+}
+
+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}$`)
+ 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
+}
+
+// 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
+}
diff --git a/internal/redact/modelfits_test.go b/internal/redact/modelfits_test.go
new file mode 100644
index 000000000..7bd450ca0
--- /dev/null
+++ b/internal/redact/modelfits_test.go
@@ -0,0 +1,70 @@
+package redact
+
+import (
+ "strings"
+ "testing"
+)
+
+// What the local model took for personal data or a secret in real agent
+// requests, and isn't: each text is as a Claude Code or Codex request had
+// it on 10-25, with the piece the model reported. Measured over 3 MB of
+// them, the model alone masked ~1,800 such pieces; the rules 17.
+func TestModelMisreadsNotMasked(t *testing.T) {
+ for _, c := range []struct{ text, value, label string }{
+ // the count each turn carries
+ {"<total_tokens>14881209 tokens left</total_tokens>", "14881209", "account_number"},
+ // run ids, hashes and versions
+ {"| 6123456789 | ci.yml | success |", "6123456789", "account_number"},
+ {"ba319a758 gateway: the lone tool_choice none", "ba319a758", "account_number"},
+ {"Update to v0.1.1442 now", "0.1.1442", "account_number"},
+ {"a screenshot of 1624x1487 pixels", "1624x1487", "private_phone"},
+ // the model's and the assistant's own names
+ {"You are powered by the model named Opus 5.5.", "Opus", "private_person"},
+ {"Claude publishes it as an Artifact.", "Claude", "private_person"},
+ {"Another Claude session holds the port.", "Another Claude", "private_person"},
+ // a user name inside a path, a skill's name
+ {"read /Users/yetone/workspace/projects/magpie/AGENTS.md", "yetone", "private_person"},
+ {"- artifact-design: Design guidance", "artifact-design", "private_person"},
+ // ids cut out of longer words
+ {`"tool_use_id":"toolu_01XyZabcDEF123456"`, "XyZabcDEF123456", "secret"},
+ {`"id":"srvtoolu_01AbCdEfGhIjKlMnOp"`, "srvtoolu_01AbCdEfGhIjKlMnOp", "secret"},
+ {"<task-id>a97c9bc67cc1f1e27</task-id>", ">a97c9bc67cc1f1e27", "secret"},
+ {"hex40 ok? 1 2f1d0c9b8a7e6f5d4c3b2a1908f7e6d5c4b3a291", "2f1d0c9b8a7e6f5d4c3b2a1908f7e6d5c4b3a291", "secret"},
+ {"919585d1700e515ac38da49e31bc60a527fc15c2 ok? 1", "919585d1700e515ac38da49e31bc60a527fc15c2 ok? 1", "secret"},
+ // names in Go's module cache, a path's piece
+ {"/Users/x/Library/Caches/go-build/63700b7ab65fd1d3@v63", "63700b7ab65fd1d3@v63", "secret"},
+ {"d6426ecaaf0a28de@v31", "d6426ecaaf0a28de@v31", "private_email"},
+ {"P=/Users/yetone/.npm/_npx/1e7f6d9597241db0", "/yetone/.", "private_email"},
+ // a piece of a base64 image
+ {"iVBORw0KGgoAAAANSUhEUgAA+k5zM7Md7tM9ehxd51xF/isvM9", "k5zM7Md7tM9ehxd51xF", "secret"},
+ // a grep alternation, a session's file, a link
+ {"rg 'modelTakes|modelFits|personFits' internal", "modelTakes|modelFits|personFits", "secret"},
+ {"wrote 31a4f944-e7cf-4f6f-acc7-eef50d9911dd.jsonl", "31a4f944-e7cf-4f6f-acc7-eef50d9911dd.jsonl", "secret"},
+ {"join at discord.gg/Ab3dEf9h today", "discord.gg/Ab3dEf9h", "secret"},
+ } {
+ f := &fakeModel{values: map[string]string{c.value: c.label}}
+ if out, n := Mask(c.text, Options{Secrets: true, Personal: true, Model: f.find}); n != 0 {
+ t.Errorf("%q as %s: masked %q", c.value, c.label, out)
+ }
+ }
+}
+
+// What the checks above leave out is still masked.
+func TestModelFindsStillMasked(t *testing.T) {
+ for _, c := range []struct{ text, value, label string }{
+ {"my account is 13393848347348", "13393848347348", "account_number"},
+ {"Ask Rina Kowalczyk about it", "Rina Kowalczyk", "private_person"},
+ {"Ludwig van Beethoven wrote it", "Ludwig van Beethoven", "private_person"},
+ {"call me on 13800138000 tonight", "13800138000", "private_phone"},
+ {"ring 020 7946 0958 after six", "020 7946 0958", "private_phone"},
+ {"send it to 42 Wallaby Way, Sydney", "42 Wallaby Way, Sydney", "private_address"},
+ {"the vault phrase is Zq8vR2mT6wLp", "Zq8vR2mT6wLp", "secret"},
+ {"api key: 9f2c4e1a7b3d5c8e9f2c4e1a7b3d5c8e", "9f2c4e1a7b3d5c8e9f2c4e1a7b3d5c8e", "secret"},
+ {"write to [email protected]", "[email protected]", "private_email"},
+ } {
+ f := &fakeModel{values: map[string]string{c.value: c.label}}
+ if out, _ := Mask(c.text, Options{Secrets: true, Personal: true, Model: f.find}); strings.Contains(out, c.value) {
+ t.Errorf("%q as %s: left in %q", c.value, c.label, out)
+ }
+ }
+}