Skip to content

Garry's Opinionated OpenClaw/Hermes Agent Brain

TypeScript

Redact cookie values, .netrc passwords and split secrets when importing transcripts (GST-2768) (#9411)

Garry Tan3cb9a80747fa
diff --git a/behavior-changes.d/transcript_secret_rules_gst2768.md b/behavior-changes.d/transcript_secret_rules_gst2768.md
new file mode 100644
index 0000000000..79dfa8b798
--- /dev/null
+++ b/behavior-changes.d/transcript_secret_rules_gst2768.md
@@ -0,0 +1 @@
+Imported conversation pages now also redact cookie values (`Cookie:` and `Set-Cookie:` headers, curl `-b`/`--cookie`; names kept), a one-line `.netrc` password, and a value that arrives alone on the line after a key or token label or in the message after any credential label (`password:`, then the password). These rules run only for transcripts; the `sources push` gate and the compiled-context scan are unchanged. Pages imported earlier are not rewritten: doctor's `transcript_secret_exposure` asks for a fresh `gbrain transcripts audit-secrets`, which now lists pages carrying cookie values, `.netrc` passwords and a key label with its value on the next line. It cannot see a value that was sent as its own message, because a stored page no longer marks where one message ends. Three cases still reach the page verbatim, as they do today: a `.netrc` entry written over several lines (`machine`, `login` and `password` each on its own line), a `-b` cookie on its own continued line of a multi-line curl command (what Chrome's "Copy as cURL" produces), and a quoted cookie value inside escaped JSON (`sid=\"…\"`).
diff --git a/changelog.d/transcript-secret-rules.md b/changelog.d/transcript-secret-rules.md
new file mode 100644
index 0000000000..6cb7dbdff2
--- /dev/null
+++ b/changelog.d/transcript-secret-rules.md
@@ -0,0 +1,16 @@
+---
+important: security
+---
+**Imported conversations no longer keep cookie values from `Cookie:` and `Set-Cookie:` headers or curl's `-b`/`--cookie`, one-line `.netrc` passwords, or a password sent as its own message after a `password:` line.** `gbrain transcripts ingest` copied these into the searchable page verbatim, because no detector knew a cookie value or a label in one message whose value came in the next. The transcript importer now redacts them. On pages imported earlier, `gbrain transcripts audit-secrets` finds the cookie values and `.netrc` passwords (doctor asks for a fresh audit), but not a password sent as its own message: a stored page no longer marks where one message ends. The `sources push` gate and the compiled-context scan are unchanged. Three cases still reach the page verbatim, as they do today: a `.netrc` entry written over several lines (`machine`, `login` and `password` each on its own line), a `-b` cookie on its own continued line of a multi-line curl command (what Chrome's "Copy as cURL" produces), and a quoted cookie value inside escaped JSON (`sid=\"…\"`).
+
+<!-- behavior-change: transcript_secret_rules_gst2768 -->
+
+### Itemized changes
+
+- `src/core/secret-scan-cookie.ts` (new): the `cookie_header` rule. Values after `Cookie:` / `Set-Cookie:` headers and after curl's `-b`/`--cookie` are redacted; cookie names, `Set-Cookie` attributes, prose, placeholders and values under 8 characters stay. Cookie values have their own echo cap (`ECHO_MAX_UNIQUE_COOKIE`), so a pasted cookie jar never uses up the shared cap for bearer, assignment and labeled values.
+- `src/core/secret-scan-labeled.ts`: transcript-only `.netrc` `password` form, and a key or token label ending its line (`here is my API key:`) whose one-token value (12+ characters, a letter and a digit, not a file name or version) is alone on the next line.
+- `src/core/secret-scan.ts`: new `ScanOpts.transcriptRules` and `ScanOpts.leadingDangling`, both off by default; `TRANSCRIPT_LANE_SCAN_OPTS` and `trailingDanglingLabel` for the transcript lane.
+- `src/core/transcripts/render.ts`: `redactSession` uses the transcript-lane options and carries a label left dangling at the end of a message into the first non-blank line of the next message only.
+- `src/core/transcripts/secret-audit.ts`: `audit-secrets` uses the same options; `TRANSCRIPT_SECRET_AUDIT_VERSION` 5 → 6, so `transcript_secret_exposure` asks for a fresh audit. `src/core/transcripts.ts` (the recent-transcripts read) uses the same options.
+- Tests: `test/transcripts-secret-cookie-header.test.ts`, `test/transcripts-secret-cross-message.test.ts`, `test/transcripts-secret-corpus.test.ts` and `test/secret-scan-push-gate-unchanged.test.ts` (a golden proving the shared scanner's other option sets are byte-identical), over the synthetic corpus `test/fixtures/transcripts/synthetic-credentials.ts`.
+- Docs: `docs/guides/data-ingestion.md#credential-redaction` and the key-files entries.
diff --git a/docs/architecture/key-files/agent-bootstrap-continued.md b/docs/architecture/key-files/agent-bootstrap-continued.md
index e9230df1bc..45bc672ea6 100644
--- a/docs/architecture/key-files/agent-bootstrap-continued.md
+++ b/docs/architecture/key-files/agent-bootstrap-continued.md
@@ -30,7 +30,7 @@
- `src/core/capability.ts` — config-plane keyless/keyed detection + the honest capability report (per-provider keyless banner: OpenAI = semantic search + auto-extraction, Voyage = semantic search, Anthropic = auto-extraction) rendered by verify and the runbook. The extraction probe resolves through the SAME shared `resolveEffectiveChatModel` the gateway's reconfigure fallback uses (`GBRAIN_MODEL` > servable file pin > key-aware tier default), so a stale unservable pin degrades identically in the report and at runtime. Key/env fold comes from `mergedProviderEnv` (`src/core/ai/provider-env.ts`). Accepted limitation (documented in the module): DB-plane overrides (`models.default`, `facts.extraction_model`) are invisible to this engine-less probe; the runtime gate in `facts/extract.ts` and the engine-aware pre-enqueue gate in `facts/backstop.ts` are the backstops.
- `src/core/readiness.ts` — capability readiness (agent operator contract A7): `ReadinessEntry {capability, state, reason, why, fix, tier, asset?, http_visible}` for embeddings, chat_llm, writeback, tool_surface, sync, harness_wiring (config tier) and worker, backup per asset, migrations, sync (probed tier); each capability's reasons are a closed exported const (`EMBEDDINGS_REASONS`, …). `configReadiness(cfg, {transport})` is synchronous and memoized per (config object, transport); its only file read is one memoized `peekLock()` (none when this process holds the lock, via `heldLockFor`), plus one process-wide gbrain-binary PATH lookup on the CLI transport only. The HTTP view drops `http_visible:false` entries and passes the rest through `redactForTransport`. `probedReadiness(engine, {cache})` never calls `getStats`/`getHealth`; 60 s cache (`createReadinessCache()` per ServeHttpContext, process-wide otherwise), single-flight, 2 s per-probe bound, stale-while-revalidate; `readinessTail` is MCP initialize's best-effort 250 ms tail. `embeddingEnablement(cfg)` is the one "turn on embeddings" fix: resolves the datastore (PGLite path, Postgres, a mount from `--brain`/`GBRAIN_BRAIN_ID`) and the column width, picks a keyed provider that fits (or asks for a key with `inputs`), and emits in-place `init --force --embedding-model … --embedding-dimensions … [--path …]` or, for a mount, `embeddings enable --brain …`; it never rebuilds a column. `exclusiveFix` turns an exclusive fix into a two-step plan (actor `user` stops the owning serve named by `lock_owner`, `then` the command) unless the command delegates to the owner. A live status-only `serve --http` marker (`liveStatusMarkers`, config plane) makes CLI `harness_wiring` `serve_status_only` with `transport: 'http'` and the status reason's fix (`httpStatusServerEntry`, shared with doctor), never "start `gbrain serve --http`" on the port it holds. `harnessWiringEntry` builds harness-native stdio registration (absolute binary, `stdioServeArgv` with `REGISTRATION_SURFACE` = `starter`, or `input.surface` from `gbrain init --surface`; `configReadiness(cfg, {transport, surface})` skips the memo when a surface is passed), shared-HTTP `bootstrap harness`, or the MEMORY_VERBS install anchor, with effects and destinations disclosed. Consumers never coach on `disabled_by_choice`. Tests: `test/readiness.test.ts`, `test/readiness-http-cost.test.ts`, `test/readiness-advice-lint.test.ts` (no hand-written enablement advice outside this module; shrink-only baseline), `test/readiness-embedding-enablement.serial.test.ts` (the E2E matrix).
- Secret and sensitivity scanning (`src/core/secret-scan.ts`, `src/core/secret-scan-allowlist.ts`, `src/core/secret-scan-stream.ts`, `src/core/secret-scan-work.ts`, `src/core/context/sensitivity-scan.ts`): see [secret-scan.md](secret-scan.md).
-- `src/core/transcripts/render.ts` — session → conversation page(s) for `gbrain transcripts ingest`. `redactSession` is two-phase over message text, speaker labels, title and every raw-meta string, BEFORE any engine write: `planRedaction(…, { highEntropy: true, echoValues })` on every field into ONE session-wide echo dictionary, then `applyRedaction` per field, so a bearer or high-entropy value claimed in one message is scrubbed where it recurs bare in any other field, in either order; echoes add nothing to `redactionCount` (fail-closed: a scanner/pattern throw aborts the session), then the operator pattern file; nested raw-meta values are dropped. This is the only lane that opts into the entropy heuristic (pasted `.env` lines are most likely here). Rendering shares the imessage-slack anchor regex with the parser and escapes body lines that would forge it; long sessions split into `-pN` parts at message boundaries once a part would pass `PART_TARGET_BYTES` (45,000 bytes, 0.9 × the content-sanity warn line `DEFAULT_BYTES_WARN`; `renderSessionParts(…, { partTargetBytes })` overrides it for measurement and refuses a non-positive or non-integer target). No message is truncated (#6388; the former 4,000-character `MESSAGE_CHAR_CAP` is gone): a message whose block would not fit a part becomes continuation blocks that repeat its speaker and timestamp anchor, cut at line breaks or, inside an over-long line, at a code-point boundary (a cut piece always lands on the generated anchor line, so every body line was escaped whole); overlap repeats only whole messages, never continuation blocks, and is trimmed so no part body passes the target (`test/transcript-long-message-render.test.ts`). `scripts/measure-transcript-split-cost.ts` imports one deterministic synthetic 1 MB session through the real redact → render → `importFromContent` path into in-memory PGLite with a token-counting stub embedder at the former 300,000-byte target and the current one: 4 → 27 pages (×6.75), 380 → 424 chunks (×1.116), 199,614 → 217,057 embed input tokens (×1.087); the extra tokens are the part headers and the two overlap messages repeated at each boundary. Each `RenderedPart` carries the `frontmatter` it owns and its `body`; on re-ingest `runTranscriptsIngest` carries any other key already on the page (a review flag another tool added) onto the re-rendered part, except the re-derived safety and atom-scan markers (#5431, `test/transcripts-retitle.test.ts`). `redactSession` plans every field with `highEntropy` and `labeledCredentials` on.
+- `src/core/transcripts/render.ts` — session → conversation page(s) for `gbrain transcripts ingest`. `redactSession` is two-phase over message text, speaker labels, title and every raw-meta string, BEFORE any engine write: `planRedaction(…, { highEntropy: true, echoValues })` on every field into ONE session-wide echo dictionary, then `applyRedaction` per field, so a bearer or high-entropy value claimed in one message is scrubbed where it recurs bare in any other field, in either order; echoes add nothing to `redactionCount` (fail-closed: a scanner/pattern throw aborts the session), then the operator pattern file; nested raw-meta values are dropped. This is the only lane that opts into the entropy heuristic (pasted `.env` lines are most likely here). Rendering shares the imessage-slack anchor regex with the parser and escapes body lines that would forge it; long sessions split into `-pN` parts at message boundaries once a part would pass `PART_TARGET_BYTES` (45,000 bytes, 0.9 × the content-sanity warn line `DEFAULT_BYTES_WARN`; `renderSessionParts(…, { partTargetBytes })` overrides it for measurement and refuses a non-positive or non-integer target). No message is truncated (#6388; the former 4,000-character `MESSAGE_CHAR_CAP` is gone): a message whose block would not fit a part becomes continuation blocks that repeat its speaker and timestamp anchor, cut at line breaks or, inside an over-long line, at a code-point boundary (a cut piece always lands on the generated anchor line, so every body line was escaped whole); overlap repeats only whole messages, never continuation blocks, and is trimmed so no part body passes the target (`test/transcript-long-message-render.test.ts`). `scripts/measure-transcript-split-cost.ts` imports one deterministic synthetic 1 MB session through the real redact → render → `importFromContent` path into in-memory PGLite with a token-counting stub embedder at the former 300,000-byte target and the current one: 4 → 27 pages (×6.75), 380 → 424 chunks (×1.116), 199,614 → 217,057 embed input tokens (×1.087); the extra tokens are the part headers and the two overlap messages repeated at each boundary. Each `RenderedPart` carries the `frontmatter` it owns and its `body`; on re-ingest `runTranscriptsIngest` carries any other key already on the page (a review flag another tool added) onto the re-rendered part, except the re-derived safety and atom-scan markers (#5431, `test/transcripts-retitle.test.ts`). `redactSession` plans every field with `TRANSCRIPT_LANE_SCAN_OPTS` (`highEntropy`, `labeledCredentials` and the transcript-only `transcriptRules`: `cookie_header`, `.netrc`, key-label join) and passes each message the label form the previous message left dangling (`trailingDanglingLabel` → `ScanOpts.leadingDangling`), so a value alone on the first line of the next message is claimed (GST-2768, `test/transcripts-secret-cross-message.test.ts`).
- `src/core/backup/status-file.ts` — ENGINE-FREE core of the monthly backup-coverage check: the cached verdict (`~/.gbrain/backup-status.json`, schema `gbrain-backup-status-v2`, which includes the `connector` asset kind; a cache with any other schema reads as absent and is recomputed; fail-open load, atomic tmp+rename write, `invalidateBackupStatus()` fired by the fix paths — `bootstrap repo` receipt write, `sources harden`, `workspacePush` finish on ok when the cache carried a warn or failing/unpushed totals (a routine healthy push leaves an ok cache alone, preserving the monthly throttle)), the notice renderer (`backupNoticeText(s, 'human'|'aggregate')` — human ≤300 chars names assets, aggregate is counts-only for remote surfaces; the remote-privacy pin), and the bounded nag gate shared by every render channel (`backupNagGate(channel, s)` on `backup-nag-state.json`, OWN schema `gbrain-backup-nag-v1` — skillpack `loadNagState` would drop the extra fields on round-trip, so only the pure policy fns `decideNagAction`/`recordNagDisplay` are reused). Budget = AND of: 24h cross-channel dampener (`last_shown_at`), per-channel ceiling 3 per pseudo-version (`YYYY-MM(checked_at)` + no-remote fingerprint — month rollover or a changed verdict re-surfaces; a same-month recompute with an unchanged verdict stays quiet), and a global cap of 3 recorded impressions per month (`global_shown_count`/`global_month`). `backupNagReadOnlyConsult` is the OpenClaw context-engine's never-writes variant; `backupSpawnDue`/`recordBackupSpawn` debounce the session-end detached spawn (no sidecar file); `maybeEmitBackupNag` is the cli.ts startup rail body (skip set incl. serve/call/jobs; `BACKUP_LOCAL_ONLY <n>` machine marker + human line). Off switches: `GBRAIN_BACKUP_CHECK=0`, config `backup.check_enabled`; interval env `GBRAIN_BACKUP_CHECK_DAYS` > config `backup.check_interval_days` > 30; values <1 or non-numeric fall back to the 30-day default (`DAYS=0` never means "always stale"; `config set` rejects <1 outright). Tests: `test/backup-status-file.serial.test.ts`. Remote evidence is identity-bound and one-hour-limited; absent, stale, future-dated or inconsistent evidence cannot produce verified recovery counts, and failed refresh does not overwrite cache.
- Workspace push and backup coverage (`src/core/workspace-push.ts`, `src/core/backup/{coverage,repository}.ts`): see [workspace-push-and-backup.md](workspace-push-and-backup.md).
- `src/core/gbrain-home.ts` — the single GBRAIN_HOME resolution choke point (delegates to config's parent-dir semantics; 0700 on create) — durability, push, hooks, and bootstrap all route through it so home semantics cannot drift.
diff --git a/docs/architecture/key-files/secret-scan.md b/docs/architecture/key-files/secret-scan.md
index af6fffc5dc..bafc148335 100644
--- a/docs/architecture/key-files/secret-scan.md
+++ b/docs/architecture/key-files/secret-scan.md
@@ -7,5 +7,6 @@ compiled-context sensitivity scan and the transcripts redactor, and the composed
sensitivity detector built on it.
- `src/core/secret-scan.ts` — pattern-based secret detection shared by `sources push`, bootstrap verify, the compiled-context sensitivity scan and the transcripts redactor. Detection is FORMAT-based, not prefix-only: vendor shapes (anthropic, openai, voyage, github, gitlab, slack, aws AKIA/ASIA, google, stripe, sendgrid, twilio, supabase sb_secret_/sbp_, npm, huggingface, `digitalocean` `do[opr]_v1_` + 64 hex, the AI-provider keys `openrouter` `sk-or-v1-` + 64 lowercase hex, `groq` `gsk_` + 52, `xai` `xai-` + 80, `perplexity` `pplx-` + 48 and `replicate` `r8_` + 37, all fixed-length with a hard right edge, gbrain), JWTs, private keys (whole-text claims, below), plus four catch-alls appended LAST (`bearer` — prebuilt two-group layout so only the token is the value, which may hold a JSON-escaped `\/` (#8266); `db_url_credentials` — the `scheme://user:pass@` span of database URLs, host/db kept; `url_credentials` — the same span for `http(s)` (scheme case-insensitive, `gi`), user 0–128 stopping at `:`/`/`, password 1–256 excluding whitespace, `@`, `"`, `'`, `/`, `?`, `#`, with a `validate` hook that rejects placeholder passwords (`<...>`, `${...}`, `$VAR`, all `*`, all `x`); `basic_auth` — two prebuilt case-insensitive forms, `Authorization: Basic` with a 4–2048 char value and bare `Basic` with 16–2048, both with a hard right edge and a `validate` that requires the value to base64-decode to printable ASCII containing `:`; it is NOT in the bearer family, so it joins neither the echo dictionary nor `secret:bearer`). The pattern contract: `CorePattern` carries optional `flags` (default `'g'`), `precheck`, `validate(value)` (O(value), run on the whole match before the claim and the union split; a rejected match is not re-tried from inside) and `since` (the gbrain version that added or last changed the rule; `SECURITY_WAVE_SINCE` = `0.60.31.0` on `digitalocean`, `url_credentials`, `basic_auth` and `private_key_pem`, `PROVIDER_KEYS_SINCE` on the five AI-provider rules (#7959), kept in step with the release that ships a rule change). Compiled patterns keep group 1 = anchor, group 2 = value. Every core rule and both `high_entropy_assignment` forms also have an escape-boundary twin (#7978), compiled right after the rule under the same name and anchored on a JSON escape (`\n`, `\r`, `\t`, `\b`, `\f`, `\uXXXX`, and since #8266 `\xNN`, `\UXXXXXXXX`), a percent-escape (`%XX`), a quoted-printable `=3D` or a terminal color code (`ESC[…m`, raw or written `\u001b[`/`\x1b[`/`\033[`/`\e[`), whose last character the default boundary reads as a word character; a twin runs only on a line `ESCAPE_IN_LINE_RE` matches, so other lines run the old list, and a prebuilt rule carries its twin as `CorePattern.escaped`. `patternSince(pattern)` reads the map; every finding of such a pattern carries `SecretFinding.since`, which the push and bootstrap refusals render. Fixed-length shapes carry a trailing negative lookahead. Per-line claimed-span dedupe is first-wins for ATTRIBUTION (order matters: `Bearer <vendor key>` keeps the vendor name, a fully covered later span is skipped) but coverage is the UNION: every unclaimed slice of a later overlapping span is claimed as a hit of the later pattern (own value, own fingerprint), so a database URL whose username is a vendor-shaped id still loses its password. The transcript-only `labeled_credential` rule (`ScanOpts.labeledCredentials`) lives in `secret-scan-labeled.ts` (Security). The opt-in `high_entropy_assignment` rule (`ScanOpts.highEntropy`; its shapes and gates live in `src/core/secret-scan-assignment.ts`, split out at the 1500-line module cap) is anchored on a credential keyword or on an identifier whose last word is `key` (`STRIPE_KEY=`, never `MONKEY=` or a bare `KEY=`) and requires a 12+ char value that contains a digit and a non-digit AND clears 3.5 bits/char on the bias-corrected (Miller-Madow) estimate `correctedEntropy`, since raw per-character entropy is capped at log2(n) and rejected most random 12-16 char secrets. It is two compiled patterns sharing the name: QUOTED (after `"` or `'`, any run of non-quote, non-whitespace characters) and UNQUOTED (the legacy `[A-Za-z0-9+/_=-]` class plus `!#$%*@^~.?<>`; never `&`, `()[]{}`, `:`, `,` or `;`, so query strings, calls and SQL `SET` lists stay intact, and a password carrying `,`/`;` matches only quoted; the last character excludes `.?!`, so a sentence's full stop is not claimed). Its `validate` rejects values that start with `scheme://`, `./`, `~/`, `${`, `$(` or `<REDACTED:`, dotted identifier paths (`process.env.X`) and `/`-paths holding a character outside the legacy class. Consumers with it on: retrieval output, transcript ingest, hooks and the hook heartbeat, the atoms drain, `embed-facts.ts` error text and the context-engine relay re-scan. Off: the push gate, bootstrap verify/repo and the compiled-context sensitivity scan. Own minimal allowlist + `<ws>/.gbrain-scan-allow` per-finding overrides — deliberately NOT the repo's `.gitleaks.toml` (a public-repo CI fixture policy); the allowlist block (`loadWorkspaceAllowlist`, the glob dialect `globToRegExp`/`matchesGlob`, `valueAllowlisted`/`pathAllowlisted`, `SCAN_ALLOW_FILENAME`, the 16-hex fingerprint floor) lives in `src/core/secret-scan-allowlist.ts` since wave 16 (G4.1, the 1500-line module cap) and is re-exported here unchanged (`test/secret-scan-allowlist.test.ts`). `correctedEntropy` is one histogram pass (distinct count = histogram size; byte-identical to the former `shannonEntropy + Set` form, `test/secret-scan-entropy-equivalence.test.ts`; ~80 → ~25 ms per 250 × 4096-char segment). `ScanOpts.work` / `RedactOpts.work` takes a `ScanWork` accumulator (`src/core/secret-scan-work.ts`: lines, regex execs, candidates per pattern, chars handed to the entropy gate counted inside `correctedEntropy`, validate calls, claims, union splits, echo sweeps) pinned exactly on the perf fixture by `test/secret-scan-work-counters.test.ts`; the perf file's absolute bounds stay the only guard on per-character cost. Deliberately NOT patterns: `sb_publishable_`, Supabase project refs (identifiers, not credentials). Never spell a literal database or `http(s)` URL with userinfo, or any credential, in this file's comments or in fixtures (assemble test values at runtime; `scripts/check-pg-url-redaction.sh` greps `src/` for every `db_url_credentials` scheme). Long lines are scanned in full (no length cap — a secret on a 1 MB minified line must still redact); what keeps that linear is bounded quantifiers on every shape whose value class could otherwise run to end-of-line — `db_url_credentials` (user ≤128 stopping at `:`/`/`; password 1–256 stopping only at whitespace, `@` and the string delimiters `"`/`'`, so unescaped `/ { } < > | ^ \` and backtick passwords redact), `jwt` (prebuilt so its boundary excludes `-` as well as `_`; segments ≤4096), `high_entropy_assignment` (≤64 identifier chars after the keyword, value ≤4096), `url_credentials` (user ≤128, password ≤256), `basic_auth` (value ≤2048, so its decode is constant work) and the private-key walks (below) — plus a per-pattern `precheck` substring gate on the catch-alls (`@` for both URL patterns; `earer`/`EARER`, since an all-caps `BEARER` scheme is accepted; a case-insensitive `basic`), a carried next-newline position in `scanPemBlocks` (sticky -1, so the header-line count is O(text) even when thousands of hits sit ahead of a newline-free multi-megabyte tail), a lazily-allocated per-line claimed-char bitmap behind the first-wins dedupe (O(value) per hit), and a windowed `buildPreview` (whole line ≤160 chars; otherwise hit−40…+80, edges snapped outward to whole spans, every claimed span in the window spliced by position, so a preview never carries a sibling secret or a fragment). `redactFindings` (= `planRedaction` + `applyRedaction`) rebuilds the text by SPAN-SPLICE in one O(text + hits) pass over the claimed spans, and fills the UNCLAIMED gaps with a bounded echo pass: the values claimed by `bearer`, `high_entropy_assignment`, `labeled_credential` and every vendor or `jwt` rule (#7978; not `basic_auth` or the two URL userinfo catch-alls) form an echo dictionary (value → pattern; floors `ECHO_MIN_CHARS_BEARER` = `ECHO_MIN_CHARS_VENDOR` = 20 / `ECHO_MIN_CHARS_ENTROPY` = 12, values ≤ `ECHO_MAX_VALUE_CHARS` = 512, the first `ECHO_MAX_UNIQUE` = 64 unique bearer, assignment and labeled values plus, under their own cap, the first `ECHO_MAX_UNIQUE_VENDOR` = 32 unique vendor or `jwt` values, in claim order, so planted vendor strings never crowd out a bearer token's echo — a value past a cap is redacted at its claim, its echoes are the accepted miss), matched by a streaming merge over the ORIGINAL text — per value, the next occurrence at or beyond the emit cursor (`indexOf` resuming at the cursor, re-sought only once the cursor passes it), leftmost-longest at each step, emitted incrementally into the unclaimed gaps — so retained state is O(values) however long the text is (occurrences are never collected into a list) (never an alternation RegExp, never over emitted tokens). Echoes add no findings. `planRedaction` feeds a caller-supplied shared map (`RedactOpts.echoValues`) and `applyRedaction` reads it at apply time, so a multi-field document scrubs an echo in one field of a value claimed in another. `basic_auth` and the URL userinfo catch-alls redact exactly what `scanText` reports; a vendor value embedded past its boundary (`token_<key>`) is scrubbed as an echo when the same value is claimed elsewhere in the document, and left as-is otherwise. PRIVATE KEYS: `pemClaims` finds `BEGIN`/`END … PRIVATE KEY` fences in two global passes and merges them in text order. BLOCK: a BEGIN whose next fence is an END within `PEM_BODY_MAX_CHARS` (16384) is claimed header through END; a block never swallows a later BEGIN. FORWARD (BEGIN with no END in view): the header plus the body lines that follow; a header followed by no body line (a marker quoted in prose) is claimed alone. BACKWARD (END with no BEGIN in view): the body lines before the fence plus the fence; an END with no body line before it is no claim. A body line is a whole-line base64 run (`A-Za-z0-9+/=`) indented by up to 16 spaces/tabs; line ends are `\n`, `\r\n` or the literal JSON escapes; interior lines are 16–128 chars, the line next to a fence and a partial line at a cut 1–128; optional RFC 1421 `Proc-Type:`/`DEK-Info:` lines and one blank line may follow BEGIN; a line with anything else, or a run over 128 chars, ends the body. Total claimed body stays within `PEM_BODY_MAX_CHARS`. Each walk stops at the neighbouring fence or the previous claim, so the pass is linear (20k unterminated BEGINs, 20k END-only fences and 1 MB of base64 lines are perf-pinned). Per-line hits that fall wholly inside a key claim are dropped (one key, one finding). A FORWARD claim's finding also carries `legacyFingerprint`, the header-only fingerprint earlier releases reported, so `workspace-push.ts` can name a stale allowlist entry; a truncated key's fingerprint covers its body and therefore depends on where the text was cut, so it is not a stable allowlist key. `privateKeySpans(text)` exports the same claims as sorted, disjoint `{start, end}` spans. Accepted misses: body on the header's own line, space-joined single-line keys, blockquoted (`> `) keys, base64 runs over 128 chars, body past 16384 chars, `http(s)` passwords containing a literal `/`, `?` or `#`, Basic values over 2048 chars, digitless assignment values, dotted passwords whose every segment starts with a letter, and unquoted passwords containing `,` or `;`. False-positive budget: `scripts/secret-scan-fp-budget.ts` diffs findings against a base ref's scanner (`--base`, default `origin/master`) (`--dir <brain>` reports per-pattern counts only, never content) and `test/secret-scan-fp-budget.test.ts` pins a synthetic brain-like fixture (zero findings on its non-secret part in both modes, every planted secret redacted). Shape tests: `test/secret-scan-credential-shapes.test.ts`, `test/secret-scan-private-key-spans.test.ts`. Perf pins: `test/secret-scan-perf.test.ts`. Retrieval output is another consumer of its canonical scanner; that output boundary does not sanitize internal evaluation/provider inputs.
+- `src/core/secret-scan-cookie.ts` — the transcript-lane `cookie_header` rule (GST-2768), run by `scanInternal` only under `ScanOpts.transcriptRules` (`TRANSCRIPT_LANE_SCAN_OPTS` in `secret-scan.ts`: redactSession, the recent-transcripts read and `transcripts audit-secrets`). `cookieHeaderValues(line)` reads the `name=value` pairs after a `Cookie:` / `Set-Cookie:` header (any case, quoted or JSON-escaped) or a curl `-b`/`--cookie` argument and returns the values only (8+ chars, no placeholder or mask); `Set-Cookie` stops after its first pair, and parsing stops at the first segment that is not `name=value`. Values join the echo dictionary at 12 chars under their own cap, `ECHO_MAX_UNIQUE_COOKIE` = 64, apart from `ECHO_MAX_UNIQUE`. Known misses: a multi-line `.netrc` stanza, a `-b` on a continued line of a multi-line curl command (Chrome's "Copy as cURL") and a JSON-escaped quoted value (`sid=\"…\"`). `test/secret-scan-push-gate-unchanged.test.ts` pins every non-transcript option set byte-identical on the synthetic corpus `test/fixtures/transcripts/synthetic-credentials.ts`.
- `src/core/secret-scan-stream.ts` — `scanTextStream(chunks, opts)`, the windowed scan of a byte stream too large to hold as one string (the push gate's staged blobs over 25 MiB). Bytes are decoded by a streaming `TextDecoder` (`ignoreBOM`, so a split multi-byte character joins and invalid bytes become U+FFFD as `Buffer.toString` makes them) and handed to `scanTextSpans` (`secret-scan.ts`: `scanText` plus each claim's absolute span, allowlisted claims kept with `finding: null`) in windows of at most `STREAM_SCAN_WINDOW_CHARS` (8 Mi UTF-16 units). Each next window starts at a line start at least `STREAM_SCAN_OVERLAP_CHARS` (64 Ki, above the longest claim: a private key's 16384-char body plus fences, a jwt's 3 × 4096) before the previous end, or mid-line at exactly the overlap (never inside a surrogate pair) when the line is too long. A window keeps the claims that start before the next window's start, the last window keeps the rest, and a claim wholly inside a span an earlier window kept (a seam's partial view, or an exact duplicate) is dropped; lines are 1-based over the whole stream. `streamScanWork` (@internal) counts windows, bytes, scanned chars and the largest window. `test/secret-scan-stream.test.ts` pins equality with `scanText` across both seams of a window, mid-line splits, split multi-byte characters, invalid UTF-8 and a BOM.
- `src/core/context/sensitivity-scan.ts` — composed detector for compiled-context entries (secret-scan → PII → path shapes → operator blocklist → operator pattern file). secret-scan OWNS credential-shaped families it also matches: a PII finding whose value (raw, or with the `Bearer ` keyword stripped) matches a secret finding's fingerprint is not reported twice; short bearer tokens under secret-scan's floor still surface as `pii:bearer`. Every family honors the same `.gbrain-scan-allow` fingerprint escape hatch. `formatSensitivityDrop(drop, workspaceRoot)` renders the one content-free stderr line `gbrain compile-context` prints per dropped entry: reason `sensitivity_scan`, the pattern family, the fingerprint and the absolute `.gbrain-scan-allow` path, never the value (`test/sensitivity-scan.test.ts`).
diff --git a/docs/architecture/key-files/security.md b/docs/architecture/key-files/security.md
index 9a8b5213fd..690b767ae1 100644
--- a/docs/architecture/key-files/security.md
+++ b/docs/architecture/key-files/security.md
@@ -27,7 +27,7 @@ Current behavior and load-bearing invariants; history belongs in Git and CHANGEL
- `src/core/scope.ts` — OAuth scope hierarchy + allowlist (the 6 scope strings, `hasScope`, `assertAllowedScopes`, `filterAllowedScopes`, `parseScopeString`, `normalizeScopesInput`) AND the anonymous-registration policy: `DCR_REGISTRABLE_SCOPES` (`read`, `write`) and `dcrScopeViolation(requested, grantTypes)` — returns `null` when the requested scopes fit the Dynamic Client Registration ceiling, otherwise the `invalid_client_metadata` message naming the offending scopes and the operator remedy (`gbrain auth register-client` / admin API / `gbrain auth rescope-client <client_id> --scopes ...`). `agent` keeps its own "operator-approved grant with explicit delegation bindings" wording; when `grantTypes` includes `client_credentials` (only reachable under `--enable-dcr-insecure`) the ceiling is `read` alone; unknown scope strings are ignored here (the unknown-filter drops them). `scopesSupportedForDiscovery({ enableDcr })` is the `scopes_supported` list for OAuth discovery (consumed by `serve-http.ts`'s `authRouterOptions`): the DCR-registrable subset (`read write`, canonical order) while DCR is enabled — so a client that copies discovery into its registration passes `dcrScopeViolation` — and every scope except `agent` otherwise; it never narrows an operator-registered client, because a client that omits `scope` at `/authorize` receives its full registered set via `grantScopes` (`oauth-grants.ts`) and an explicit request is intersected with the registration. The DCR constants and the helper sit BELOW `ALLOWED_SCOPES_LIST`, and no comment line pairs that identifier with `[`, because `scripts/check-admin-scope-drift.sh` extracts the allowlist block with an awk match on exactly that pair. Pinned by `test/scope.test.ts` + `test/oauth-dcr-scope-ceiling.test.ts` + the discovery test in `test/e2e/serve-http-consent.test.ts`.
-- `src/core/secret-scan-labeled.ts` — the transcript-lane `labeled_credential` detector (#6147 idea, widened), compiled by `secret-scan.ts` only under `ScanOpts.labeledCredentials` (transcript pages, the recent-transcripts read and `transcripts audit-secrets`), after every other rule so a vendor or entropy claim keeps attribution. SINGLE labels (`password|passwd|passcode|passphrase|pwd`, optional identifier prefix, JSON-key quote, markdown bold) before `:`/`=`/`:`, and PAIR labels (`login|log-in|credentials|creds|user/pass|username/password|…`) before `:`/`=`/`:`/` - `/nothing then `user / pass` or `user:pass`, each in a bare and a quoted/backticked form; only the password half is claimed. `labeledValueIsCredential(value, form, head)` (the scanner passes the match head to `validate`) rejects placeholders, masks, templating, URLs, paths, calls, dotted references, digitless code identifiers, a backtick that closes a code span holding the label, a meeting link's `?pwd=`, and `LABELED_STOPLIST` words; a pair's password also needs 4+ chars with a letter and a digit or symbol, and its user half must not be a stopword. W4.1 widens it: CLI flags with a separate value (`--password X`, `--pass "a b"`; suffixed flags such as `--password-file` are not labels), an env-name suffix after the label (`PASSWORD_DB=`; a setting suffix such as `_FILE`/`_MIN_LENGTH`/`_HINT` rejects via `settingSuffix`), a `cli` form (prefixed flags such as `--db-password`, `--pw`, openssl `-passin pass:`) whose value may not start with `-` (other forms keep `-`-leading passwords), the setting-suffix exemption only for single labels, and Markdown tables (`tableCredentialCells`, `pw`/`Password (prod)` headers, `|-|` separators, a per-row column Set so a row is linear in cells with per-scan `TableScanState`: cells under a password-label header column and the value cell of a non-header `| password | X |` row; escaped pipes, no outer pipes, several columns). `danglingLabel` gates the next-line continuation patterns per form: `pair` after a dangling pair, `single` (the whole next line is the value, validated as a single label) after a line ending in a single label and delimiter; such a line, and a table row with a claimed cell, is scanned even when shorter than 8 chars. Claimed values join the echo dictionary at `ECHO_MIN_CHARS_LABELED` = 8 when `labeledEchoEligible`. Every quantifier is bounded (perf-pinned in `test/secret-scan-perf.test.ts`); acceptance table in `test/transcript-labeled-credential.test.ts`; user doc `docs/guides/data-ingestion.md#credential-redaction`.
+- `src/core/secret-scan-labeled.ts` — the transcript-lane `labeled_credential` detector (#6147 idea, widened), compiled by `secret-scan.ts` only under `ScanOpts.labeledCredentials` (transcript pages, the recent-transcripts read and `transcripts audit-secrets`), after every other rule so a vendor or entropy claim keeps attribution. SINGLE labels (`password|passwd|passcode|passphrase|pwd`, optional identifier prefix, JSON-key quote, markdown bold) before `:`/`=`/`:`, and PAIR labels (`login|log-in|credentials|creds|user/pass|username/password|…`) before `:`/`=`/`:`/` - `/nothing then `user / pass` or `user:pass`, each in a bare and a quoted/backticked form; only the password half is claimed. `labeledValueIsCredential(value, form, head)` (the scanner passes the match head to `validate`) rejects placeholders, masks, templating, URLs, paths, calls, dotted references, digitless code identifiers, a backtick that closes a code span holding the label, a meeting link's `?pwd=`, and `LABELED_STOPLIST` words; a pair's password also needs 4+ chars with a letter and a digit or symbol, and its user half must not be a stopword. W4.1 widens it: CLI flags with a separate value (`--password X`, `--pass "a b"`; suffixed flags such as `--password-file` are not labels), an env-name suffix after the label (`PASSWORD_DB=`; a setting suffix such as `_FILE`/`_MIN_LENGTH`/`_HINT` rejects via `settingSuffix`), a `cli` form (prefixed flags such as `--db-password`, `--pw`, openssl `-passin pass:`) whose value may not start with `-` (other forms keep `-`-leading passwords), the setting-suffix exemption only for single labels, and Markdown tables (`tableCredentialCells`, `pw`/`Password (prod)` headers, `|-|` separators, a per-row column Set so a row is linear in cells with per-scan `TableScanState`: cells under a password-label header column and the value cell of a non-header `| password | X |` row; escaped pipes, no outer pipes, several columns). `danglingLabel` gates the next-line continuation patterns per form: `pair` after a dangling pair, `single` (the whole next line is the value, validated as a single label) after a line ending in a single label and delimiter; such a line, and a table row with a claimed cell, is scanned even when shorter than 8 chars. Claimed values join the echo dictionary at `ECHO_MIN_CHARS_LABELED` = 8 when `labeledEchoEligible`. Every quantifier is bounded (perf-pinned in `test/secret-scan-perf.test.ts`); acceptance table in `test/transcript-labeled-credential.test.ts`; user doc `docs/guides/data-ingestion.md#credential-redaction`. GST-2768: `TRANSCRIPT_LABELED_PATTERNS` (compiled only under `ScanOpts.transcriptRules`) adds the `.netrc` `password` form and the `key` continuation after `danglingKeyLabel` (a key or token label ending its line), validated by `keyLabelValueIsCredential` (12+ chars, one token, a letter and a digit).
- `src/core/ssrf-validate.ts` — DNS-rebinding-defended URL validation. `validateAndResolveUrl(url)` resolves the hostname via `dns.lookup({all: true, family: 0})`, checks EVERY A and AAAA record against the internal-IP deny list, and returns the resolved IP so callers fetch by IP (validation IP === fetch IP defeats DNS rebinding). `fetchWithSSRFGuard(url, opts)` does redirect-aware fetching with per-hop re-validation (max 3 hops by default). Reusable across all URL-fetching features. Test seam `__setDnsLookupForTests` for hermetic tests.
diff --git a/docs/guides/data-ingestion.md b/docs/guides/data-ingestion.md
index bec5b5c475..0cae7d70eb 100644
--- a/docs/guides/data-ingestion.md
+++ b/docs/guides/data-ingestion.md
@@ -121,7 +121,23 @@ forms are recognized, with bare, quoted or backticked values:
- Markdown table cells: every cell under a column headed `Password`, `pwd`,
`DB password` and the like, and the value in a `| password | … |` row,
including rows without outer pipes, escaped `\|` pipes and tables with
- several credential columns.
+ several credential columns;
+- a one-line `.netrc` entry, `machine host login alice password …`;
+- a key or token label that ends its line (`here is my API key:`,
+ `ACCESS_TOKEN=`), with one value of 12+ characters holding a letter and a
+ digit alone on the next line;
+- a label that ends one message, with the value alone on the first line of
+ the next message (`password:`, then the password as its own message).
+
+Cookie values are redacted too (`cookie_header`): after a `Cookie:` or
+`Set-Cookie:` header (raw headers, `curl -H`, a copy-as-fetch JSON blob) and
+after `-b`/`--cookie` on the same line as `curl`, every value of 8+
+characters is replaced and the cookie names and `Set-Cookie` attributes
+stay. These transcript-only rules never run in the `sources push` gate or
+the compiled-context scan.
+
+Known gaps: three cases still reach the page verbatim, as they did before
+these rules: a `.netrc` entry written over several lines (`machine`, `login` and `password` each on its own line), a `-b` cookie on its own continued line of a multi-line curl command (what Chrome's "Copy as cURL" produces), and a quoted cookie value inside escaped JSON (`sid=\"…\"`).
To keep prose and code intact, a value is never redacted when it is a
placeholder (`<…>`, `${…}`, `$VAR`), a mask (`****`), a URL, a path, a
@@ -138,7 +154,9 @@ value of 8+ characters that is not a stoplisted word is also scrubbed where
the session repeats it bare.
Pages imported before this detector (or a later widening of it) shipped are
-not rewritten automatically, so run the audit again after upgrading. `gbrain transcripts audit-secrets --json` (read-only; all
+not rewritten automatically, so run the audit again after upgrading. The audit
+finds every shape above except a value sent as its own message: a stored page
+no longer marks where one message ends. `gbrain transcripts audit-secrets --json` (read-only; all
sources, or one with `--source-id`) lists the conversation pages that still
carry a credential: slug, source, hit count per pattern and line numbers,
never the text. The doctor check `transcript_secret_exposure` reads the
diff --git a/src/core/secret-scan-cookie.ts b/src/core/secret-scan-cookie.ts
new file mode 100644
index 0000000000..78a9f90117
--- /dev/null
+++ b/src/core/secret-scan-cookie.ts
@@ -0,0 +1,73 @@
+/**
+ * secret-scan-cookie.ts: the transcript-lane `cookie_header` rule (GST-2768).
+ * A session cookie pasted into an agent session (a curl `-H 'Cookie: …'` or
+ * `-b` argument, raw request or response headers, a copy-as-fetch JSON blob) is not a known token shape, so no other rule
+ * claimed it and it reached the conversation page verbatim.
+ *
+ * OPT-IN (`ScanOpts.transcriptRules`): only the transcript page lane and
+ * `gbrain transcripts audit-secrets` turn it on; the push gate and every other
+ * surface keep it off.
+ *
+ * After a `Cookie:` header (any case, optionally quoted or JSON-escaped) or a
+ * curl `-b` / `--cookie` argument (only after `curl` earlier on the line, so
+ * `git checkout -b name=value` is not one), each `name=value` pair separated by `;` is
+ * read; only the values are claimed, so cookie names stay readable. After
+ * `Set-Cookie:` only the first pair is a cookie: the attributes that follow
+ * (`Path=/`, `Max-Age=3600`) are kept. Parsing stops at the first segment
+ * that is not `name=value`, so prose (`Cookie: chocolate chip`) is never
+ * claimed. A `'` or `,` inside a value and a JSON-escaped `\/` are part of it.
+ * Values shorter than 8 characters (preference flags such as
+ * `theme=dark`), placeholders (`<…>`, `$VAR`, `{…}`, `%VAR%`) and masks (`...`, `***`)
+ * are left alone. Every quantifier is bounded; the parse is linear in the line.
+ * Not caught: a `-b` on a continued line of a multi-line curl command
+ * (Chrome's "Copy as cURL") and a JSON-escaped quoted value (`sid=\"…\"`).
+ */
+
+const COOKIE_HEAD_RE = /(?:(?:^|[^A-Za-z0-9_-])(set-)?cookie\\?["'`]?\s{0,4}:|(?:^|\s)(-b|--cookie)(?=[\s=]))[\s=]{0,4}\\?["'`]?/gi;
+const COOKIE_PAIR_RE = /([!#$%&*+.^_|~0-9A-Za-z-]{1,128})=("?)((?:[^\s;"',\\]|[',](?=[^\s;"',\\])|\\\/){0,4096})/y;
+const COOKIE_SEP_RE = /\s{0,4};\s{0,4}/y;
+const PLACEHOLDER_RE = /^(?:[<${[]|%[A-Za-z_][A-Za-z0-9_]{0,64}%$)/;
+const CURL_RE = /(?:^|[^A-Za-z0-9_-])curl(?:\.exe)?(?:\s|$)/i;
+const MASK_RE = /^[.*xX•_-]+$/;
+
+/**
+ * Cap on the unique `cookie_header` values in the echo dictionary, apart from
+ * ECHO_MAX_UNIQUE and ECHO_MAX_UNIQUE_VENDOR, so a pasted cookie jar never
+ * crowds out a later bearer, assignment or labeled value's echo.
+ */
+export const ECHO_MAX_UNIQUE_COOKIE = 64;
+
+/** Minimum cookie value length claimed. */
+export const COOKIE_VALUE_MIN_CHARS = 8;
+
+/** Cheap gate before the header regex runs on a line. */
+export const COOKIE_PRECHECK_RE = /cookie|-b\s/i;
+
+/** The cookie values on `line`: `start` of the value, the value, and `from`, where its header starts. */
+export function cookieHeaderValues(line: string): Array<{ start: number; value: string; from: number }> {
+ const out: Array<{ start: number; value: string; from: number }> = [];
+ let curlAt: number | undefined;
+ COOKIE_HEAD_RE.lastIndex = 0;
+ for (let head = COOKIE_HEAD_RE.exec(line); head !== null; head = COOKIE_HEAD_RE.exec(line)) {
+ const setCookie = head[1] !== undefined;
+ let at = COOKIE_HEAD_RE.lastIndex;
+ if (head[2] !== undefined && !((curlAt ??= line.search(CURL_RE)) >= 0 && curlAt < head.index)) continue;
+ for (;;) {
+ COOKIE_PAIR_RE.lastIndex = at;
+ const m = COOKIE_PAIR_RE.exec(line);
+ if (m === null) break;
+ const quoted = m[2] === '"';
+ if (quoted && line[COOKIE_PAIR_RE.lastIndex] !== '"') break;
+ const value = m[3]!;
+ if (value.length >= COOKIE_VALUE_MIN_CHARS && !PLACEHOLDER_RE.test(value) && !MASK_RE.test(value)) {
+ out.push({ start: m.index + m[1]!.length + 1 + m[2]!.length, value, from: head.index });
+ }
+ if (setCookie) break;
+ COOKIE_SEP_RE.lastIndex = COOKIE_PAIR_RE.lastIndex + (quoted ? 1 : 0);
+ if (COOKIE_SEP_RE.exec(line) === null) break;
+ at = COOKIE_SEP_RE.lastIndex;
+ }
+ COOKIE_HEAD_RE.lastIndex = Math.max(COOKIE_HEAD_RE.lastIndex, at);
+ }
+ return out;
+}
diff --git a/src/core/secret-scan-labeled.ts b/src/core/secret-scan-labeled.ts
index 772e1692fb..36197b72d9 100644
--- a/src/core/secret-scan-labeled.ts
+++ b/src/core/secret-scan-labeled.ts
@@ -38,6 +38,13 @@
* key/value row, with escaped pipes, rows without outer pipes and several
* credential columns.
*
+ * GST-2768 adds, behind `ScanOpts.transcriptRules` (the transcript page lane
+ * and its audit only, see `TRANSCRIPT_LABELED_PATTERNS`): a `.netrc` line's
+ * `password <value>`, and a key or token label left dangling at a line end
+ * (`here is my API key:`, `ACCESS_TOKEN=`) with its value alone on the next
+ * line. The transcript lane also carries a dangling label of any form into
+ * the first line of the NEXT message (`ScanOpts.leadingDangling`).
+ *
* Accepted misses: an unquoted multi-word passphrase (`login: alice / pass
* word`), a delimiter-free single label (`the password is hunter2`), a pair
* split by anything but one line break, a concatenated short flag
@@ -68,6 +75,9 @@ const CLI_HEAD = '(?:^|\\s)--?(?!(?:no|skip|ask|prompt|reset|show|print|change|c
/** openssl's `-passin pass:X` / `-passout pass:X`. */
const OPENSSL_PASS_HEAD = '(?:^|\\s)-pass(?:in|out)\\s{1,4}pass:';
+/** The label form a line leaves dangling for the next line: `key` is the transcript-lane key or token label. */
+export type DanglingForm = 'single' | 'pair' | 'key';
+
export interface LabeledPattern {
source: string;
/** `cli`: a single label written as a command-line flag, whose value never starts with `-` (that is the next flag). */
@@ -76,6 +86,13 @@ export interface LabeledPattern {
continuation?: 'single' | 'pair';
}
+/** A transcript-lane labeled shape; `key` is a value under a key or token label, checked by `keyLabelValueIsCredential`. */
+export interface TranscriptLabeledPattern {
+ source: string;
+ form: 'single' | 'key';
+ continuation?: 'key';
+}
+
/** Group 1 = everything before the value, group 2 = the value (the scanner's shape). */
export const LABELED_CREDENTIAL_PATTERNS: readonly LabeledPattern[] = [
{ form: 'single', source: `(${SINGLE_HEAD}${QUOTE})(${QUOTED_VALUE})(?=${QUOTE})` },
@@ -91,6 +108,82 @@ export const LABELED_CREDENTIAL_PATTERNS: readonly LabeledPattern[] = [
{ form: 'single', continuation: 'single', source: `(^\\s{0,8})(${BARE_VALUE})(?=[.,;]?\\s*$)` },
];
+/** A key or token label (`API key`, `access_token`, `client secret`), transcript lane only. */
+const KEY_LABEL = '(?:api[ _-]?key|access[ _-]?key|secret[ _-]?key|client[ _-]?secret|secret|token)s?';
+const NETRC_HEAD = '(?:^|\\s)(?:machine\\s{1,4}[^\\s]{1,253}|default)(?:\\s{1,4}(?:login|account)\\s{1,4}[^\\s]{1,128}){0,2}\\s{1,4}password\\s{1,4}';
+
+/**
+ * GST-2768: the transcript-lane-only labeled shapes (`ScanOpts.transcriptRules`), claimed as
+ * `labeled_credential`: a `.netrc` password, and the value on the line after a dangling key label.
+ */
+export const TRANSCRIPT_LABELED_PATTERNS: readonly TranscriptLabeledPattern[] = [
+ { form: 'single', source: `(${NETRC_HEAD}${QUOTE})(${QUOTED_VALUE})(?=${QUOTE})` },
+ { form: 'single', source: `(${NETRC_HEAD})(${BARE_VALUE})${BARE_END}` },
+ { form: 'key', continuation: 'key', source: `(^\\s{0,8}${QUOTE})(${QUOTED_VALUE})(?=${QUOTE}[,;]?\\s*$)` },
+ { form: 'key', continuation: 'key', source: `(^\\s{0,8})(${BARE_VALUE})(?=[.,;]?\\s*$)` },
+];
+
+/** Cheap gate before the `.netrc` pattern runs on a line. */
+export const NETRC_PRECHECK_RE = /password/i;
+
+// nosemgrep: javascript.lang.security.audit.detect-non-literal-regexp.detect-non-literal-regexp -- compile-time literal; bounded quantifiers
+const KEY_DANGLING_RE = new RegExp(`${LEFT}${KEY_LABEL}${LABEL_END}${BOLD}${QUOTE}?\\s{0,4}${DELIM}${BOLD}\\s{0,4}$`, 'i');
+const KEY_PRECHECK_RE = /key|secret|token/i;
+
+/** True when `line` ends in a key or token label with nothing after it (`here is my API key:`). Tests the last 128 characters only. */
+export function danglingKeyLabel(line: string): boolean {
+ if (!KEY_PRECHECK_RE.test(line)) return false;
+ return KEY_DANGLING_RE.test(line.length > 128 ? line.slice(-128) : line);
+}
+
+/**
+ * A value alone on the line after a dangling key label: one token of 12+ characters with a
+ * letter and a digit that is not a file name or version and passes the single-label checks,
+ * so prose (`hold on`), short words, paths and code references under a `token:` heading stay.
+ */
+export function keyLabelValueIsCredential(value: string, head = ''): boolean {
+ if (value.length < 12 || /\s/.test(value) || !LETTER_RE.test(value) || !/[0-9]/.test(value)) return false;
+ if (FILE_NAME_RE.test(value) || KEY_VERSION_RE.test(value)) return false;
+ return labeledValueIsCredential(value, 'single', head);
+}
+
+/** A file name or relative path ending in an extension (`src/core/foo1.ts`, `config2.json`) under a key label. */
+const FILE_NAME_RE = /^[\w.-]{1,128}(?:\/[\w.-]{1,128}){0,16}\.[A-Za-z][A-Za-z0-9]{0,4}$/;
+/** A version string (`v2.1.0-rc1-build`). */
+const KEY_VERSION_RE = /^v?\d{1,6}(?:\.\d{1,6}){1,3}(?:[-+][\w.-]{0,64})?$/;
+
+/**
+ * The transcript lane's scan options (redactSession, `gbrain transcripts
+ * audit-secrets`, the session-corpus reader): the opt-in high-entropy and
+ * labeled-credential detectors plus the transcript-only rules
+ * (`ScanOpts.transcriptRules`). Every other surface keeps the shared defaults.
+ */
+export const TRANSCRIPT_LANE_SCAN_OPTS: Readonly<{ highEntropy: true; labeledCredentials: true; transcriptRules: true }> = Object.freeze({
+ highEntropy: true,
+ labeledCredentials: true,
+ transcriptRules: true,
+});
+
+/** The scan options that decide which dangling labels count (a structural slice of `ScanOpts`). */
+interface DanglingOpts { labeledCredentials?: boolean; transcriptRules?: boolean }
+
+/** The label form `line` leaves dangling for the next line under `opts`, or null. */
+export function danglingFor(line: string, opts: DanglingOpts): DanglingForm | null {
+ const labeled = opts.labeledCredentials === true ? danglingLabel(line) : null;
+ if (labeled) return labeled;
+ return opts.transcriptRules === true && danglingKeyLabel(line) ? 'key' : null;
+}
+
+/**
+ * The label form the last line of `text` leaves dangling (`password:`,
+ * `login: alice /`, `here is my API key:`), for the next message's
+ * `ScanOpts.leadingDangling`. Null when the options carry no labeled rules.
+ */
+export function trailingDanglingLabel(text: string, opts: DanglingOpts): DanglingForm | null {
+ const trimmed = text.trimEnd();
+ return danglingFor(trimmed.slice(trimmed.lastIndexOf('\n') + 1), opts);
+}
+
/**
* #7997: an importer redaction marker (`<REDACTED:kind>`) with its colon swapped, the same length, so the label
* patterns read it as one word. Its colon used to split it into a claimed `user:pass` pair, while a credential written
diff --git a/src/core/secret-scan.ts b/src/core/secret-scan.ts
index 0ea88cfa3d..7b786e6e6d 100644
--- a/src/core/secret-scan.ts
+++ b/src/core/secret-scan.ts
@@ -35,7 +35,11 @@ import {
LABELED_CREDENTIAL_PATTERNS,
ECHO_MIN_CHARS_LABELED,
LABELED_PRECHECK_RE,
- danglingLabel,
+ TRANSCRIPT_LABELED_PATTERNS,
+ NETRC_PRECHECK_RE,
+ danglingFor,
+ keyLabelValueIsCredential,
+ type DanglingForm,
labeledEchoEligible,
labeledValueIsCredential,
neutralizeRedactionMarkers,
@@ -88,6 +92,13 @@ export interface ScanOpts {
* transcript audit only. Default false.
*/
labeledCredentials?: boolean;
+ /**
+ * Opt-in transcript-lane rules (GST-2768): `cookie_header` (secret-scan-cookie.ts), the `.netrc` password and the
+ * key-label next-line value (secret-scan-labeled.ts). Only via `TRANSCRIPT_LANE_SCAN_OPTS`. Default false.
+ */
+ transcriptRules?: boolean;
+ /** Label form the previous message left dangling (`trailingDanglingLabel`): line 1 here is read as its value. Default none. */
+ leadingDangling?: DanglingForm | null;
/** Work counters the scan fills in (secret-scan-work.ts); absent means no counting. */
work?: ScanWork;
}
@@ -103,6 +114,8 @@ import {
} from './secret-scan-assignment.ts';
import type { ScanWork } from './secret-scan-work.ts';
export { createScanWork, type ScanWork } from './secret-scan-work.ts';
+import { COOKIE_PRECHECK_RE, ECHO_MAX_UNIQUE_COOKIE, cookieHeaderValues } from './secret-scan-cookie.ts';
+export { TRANSCRIPT_LANE_SCAN_OPTS, trailingDanglingLabel } from './secret-scan-labeled.ts';
// ── Patterns ────────────────────────────────────────────────────────────────
//
@@ -134,7 +147,7 @@ interface CompiledPattern {
/** See CorePattern.validate; `head` is the match text before the value. */
validate?: (value: string, head: string) => boolean;
/** Runs only on the line after one that ends in a dangling credential label of this form. */
- continuation?: 'single' | 'pair';
+ continuation?: DanglingForm;
/** The text the regex reads instead of the line, the same length (offsets and reported values come from the line). */
subject?: (line: string) => string;
/** An ESCAPE_BOUNDARY twin: runs only on a line ESCAPE_IN_LINE_RE matches. */
@@ -661,7 +674,7 @@ export function privateKeySpans(text: string): Array<{ start: number; end: numbe
const compiledPatterns = new Map<string, CompiledPattern[]>();
function compilePatterns(opts: ScanOpts): CompiledPattern[] {
- const key = `${opts.highEntropy === true}|${opts.labeledCredentials === true}`;
+ const key = `${opts.highEntropy === true}|${opts.labeledCredentials === true}|${opts.transcriptRules === true}`;
let compiled = compiledPatterns.get(key);
if (!compiled) compiledPatterns.set(key, compiled = buildPatterns(opts));
return compiled;
@@ -706,6 +719,18 @@ function buildPatterns(opts: ScanOpts): CompiledPattern[] {
});
}
}
+ if (opts.transcriptRules) {
+ for (const p of TRANSCRIPT_LABELED_PATTERNS) {
+ out.push({
+ name: 'labeled_credential',
+ // nosemgrep: javascript.lang.security.audit.detect-non-literal-regexp.detect-non-literal-regexp -- compile-time literal; bounded quantifiers, pinned by test/secret-scan-perf.test.ts
+ re: new RegExp(p.source, 'gi'),
+ ...(p.continuation ? { continuation: p.continuation } : { precheck: (line: string) => NETRC_PRECHECK_RE.test(line) }),
+ validate: p.form === 'key' ? keyLabelValueIsCredential : (value: string, head: string) => labeledValueIsCredential(value, 'single', head),
+ subject: neutralizeRedactionMarkers,
+ });
+ }
+ }
return out;
}
@@ -869,11 +894,14 @@ function scanInternal(text: string, opts: ScanOpts): RawHit[] {
let offset = 0;
// W4.1: Markdown table state for the labeled lane (credential columns of the table being scanned).
const table = opts.labeledCredentials === true ? newTableScanState() : null;
+ let leadingLine = 0;
for (let i = 0; i < lines.length; i++) {
const line = lines[i] ?? '';
const lineStart = offset;
offset += line.length + 1;
- const dangling = opts.labeledCredentials === true && i > 0 ? danglingLabel(lines[i - 1] ?? '') : null;
+ // The previous message's dangling label reads the first non-blank line here.
+ if (i === leadingLine && opts.leadingDangling && line.trim() === '') leadingLine = i + 1;
+ const dangling = i === leadingLine ? (opts.leadingDangling ?? null) : i > 0 ? danglingFor(lines[i - 1] ?? '', opts) : null;
const cells = table ? tableCredentialCells(line, lines[i + 1], table) : [];
if (line.length < 8 && !dangling && cells.length === 0) continue;
// ENG-12: a line wholly inside a private-key claim is already redacted by
@@ -954,6 +982,17 @@ function scanInternal(text: string, opts: ScanOpts): RawHit[] {
}
}
for (const c of cells) if (!taken || !anyTaken(taken, c.start, c.start + c.value.length)) { taken ??= new Uint8Array(line.length); claim('labeled_credential', c.value, c.start, c.start); }
+ // GST-2768: cookie values (transcript lane), union coverage around anything already claimed.
+ if (opts.transcriptRules === true && COOKIE_PRECHECK_RE.test(line)) {
+ for (const c of cookieHeaderValues(line)) {
+ taken ??= new Uint8Array(line.length);
+ for (let a = c.start, k = c.start, end = c.start + c.value.length; k <= end; k++) {
+ if (k < end && !taken[k]) continue;
+ if (a < k) claim('cookie_header', line.slice(a, k), a, c.from);
+ a = k + 1;
+ }
+ }
+ }
}
return hits;
}
@@ -1205,9 +1244,9 @@ export function scanFiles(paths: string[], opts: ScanOpts = {}): SecretFinding[]
// `pwd: 1234` never scrubs every later "1234"), must be at most
// ECHO_MAX_VALUE_CHARS long,
// and only the first ECHO_MAX_UNIQUE unique bearer, assignment and labeled
-// values plus the first ECHO_MAX_UNIQUE_VENDOR unique vendor or jwt values, in
-// claim order, join (two caps, so planted vendor strings never crowd out a
-// bearer token's echo). A value past a cap is still redacted at its claimed
+// values, the first ECHO_MAX_UNIQUE_VENDOR vendor or jwt values and the first
+// ECHO_MAX_UNIQUE_COOKIE cookie values, in claim order, join (three caps, so
+// planted vendor strings or a cookie jar never crowd out a bearer's echo). A value past a cap is still redacted at its claimed
// span; only its echoes are the accepted miss.
//
// The pass is a streaming merge over the ORIGINAL text: per value, the
@@ -1321,12 +1360,14 @@ function addEchoValue(into: EchoDictionary, pattern: string, value: string): voi
? ECHO_MIN_CHARS_ENTROPY
: pattern === 'labeled_credential'
? ECHO_MIN_CHARS_LABELED
+ : pattern === 'cookie_header'
+ ? ECHO_MIN_CHARS_ENTROPY
: VENDOR_ECHO_PATTERNS.has(pattern) ? ECHO_MIN_CHARS_VENDOR : Infinity;
if (value.length < floor || value.length > ECHO_MAX_VALUE_CHARS || into.has(value)) return;
- const vendor = VENDOR_ECHO_PATTERNS.has(pattern);
+ const bucket = (p: string): 'cookie' | 'vendor' | 'shared' => (p === 'cookie_header' ? 'cookie' : VENDOR_ECHO_PATTERNS.has(p) ? 'vendor' : 'shared');
let used = 0;
- for (const claimedBy of into.values()) if (VENDOR_ECHO_PATTERNS.has(claimedBy) === vendor) used++;
- if (used >= (vendor ? ECHO_MAX_UNIQUE_VENDOR : ECHO_MAX_UNIQUE)) return;
+ for (const claimedBy of into.values()) if (bucket(claimedBy) === bucket(pattern)) used++;
+ if (used >= { cookie: ECHO_MAX_UNIQUE_COOKIE, vendor: ECHO_MAX_UNIQUE_VENDOR, shared: ECHO_MAX_UNIQUE }[bucket(pattern)]) return;
into.set(value, pattern);
const unescaped = value.replaceAll('\\/', '/');
if (unescaped !== value) addEchoValue(into, pattern, unescaped);
diff --git a/src/core/transcripts.ts b/src/core/transcripts.ts
index 7f869930b0..5ee1b580af 100644
--- a/src/core/transcripts.ts
+++ b/src/core/transcripts.ts
@@ -19,7 +19,7 @@ import { join, basename, dirname } from 'node:path';
import type { BrainEngine } from './engine.ts';
import type { Action } from './agent-output.ts';
import { isDreamOutput } from './cycle/transcript-discovery.ts';
-import { redactFindings } from './secret-scan.ts';
+import { TRANSCRIPT_LANE_SCAN_OPTS, redactFindings } from './secret-scan.ts';
export interface RecentTranscriptOpts {
/** Window in days. Default 7. */
@@ -86,7 +86,7 @@ export async function listRecentTranscripts(
const name = basename(c.path);
const dateMatch = DATE_RE.exec(name);
// Redact the whole file before the summary/full-read cap cuts it.
- const text = redactFindings(raw, { highEntropy: true, labeledCredentials: true }).text;
+ const text = redactFindings(raw, TRANSCRIPT_LANE_SCAN_OPTS).text;
out.push({
path: name,
date: dateMatch ? dateMatch[1] : null,
diff --git a/src/core/transcripts/render.ts b/src/core/transcripts/render.ts
index a12401f818..570c55e4bf 100644
--- a/src/core/transcripts/render.ts
+++ b/src/core/transcripts/render.ts
@@ -47,7 +47,8 @@ import { gbrainPath } from '../config.ts';
import { dumpFrontmatterYaml } from '../data-frontmatter.ts';
import { join } from 'node:path';
import { DEFAULT_BYTES_WARN } from '../content-sanity.ts';
-import { applyRedaction, planRedaction, type EchoDictionary, type RedactionPlan } from '../secret-scan.ts';
+import { TRANSCRIPT_LANE_SCAN_OPTS, applyRedaction, planRedaction, trailingDanglingLabel, type EchoDictionary, type RedactionPlan } from '../secret-scan.ts';
+import type { DanglingForm } from '../secret-scan-labeled.ts';
import { loadPatterns } from '../skillpack/harvest-lint.ts';
import { sanitizeForJsonb } from '../batch-rows.ts';
import { ensureWellFormed } from '../text-safe.ts';
@@ -146,6 +147,12 @@ export function loadImportRedactionPatterns(userPatternsPath?: string): ImportRe
* password / login / credentials label (`password: hunter2`, `login alice /
* hunter2`); a claimed value of 8+ characters that is not a stoplisted word
* joins the echo dictionary below.
+ * Also transcript-lane only (`TRANSCRIPT_LANE_SCAN_OPTS.transcriptRules`,
+ * GST-2768): `cookie_header` claims cookie values after a `Cookie:` /
+ * `Set-Cookie:` header or a curl `-b` argument (names kept), a `.netrc`
+ * password is claimed, and a label left dangling at the end of one message
+ * (`password:`, `here is my API key:`) claims the value alone on the first
+ * line of the NEXT message, never further.
* Every match becomes `<REDACTED:pattern>`; user patterns become
* `<REDACTED:user-pattern>`.
*
@@ -170,14 +177,14 @@ export function redactSession(
let imperativesFlagged = 0;
const echoValues: EchoDictionary = new Map();
- const plan = (text: string): RedactionPlan =>
+ const plan = (text: string, leadingDangling: DanglingForm | null = null): RedactionPlan =>
// sanitizeForJsonb (NUL-strip + well-form): transcripts capture raw tool
// output that legitimately carries U+0000, which Postgres text/jsonb
// reject at the write boundary (#4392).
- // highEntropy + labeledCredentials: transcripts opt into the assignment
- // heuristic and the labeled-credential detector (see doc comment above);
- // the shared scanner keeps both off by default.
- planRedaction(sanitizeForJsonb(text), { highEntropy: true, labeledCredentials: true, echoValues });
+ // TRANSCRIPT_LANE_SCAN_OPTS: transcripts opt into the assignment
+ // heuristic, the labeled-credential detector and the transcript-only
+ // rules (see doc comment above); the shared scanner keeps all off by default.
+ planRedaction(sanitizeForJsonb(text), { ...TRANSCRIPT_LANE_SCAN_OPTS, leadingDangling, echoValues });
const apply = (p: RedactionPlan): string => {
redactionCount += p.redactions.length;
@@ -193,14 +200,16 @@ export function redactSession(
// Phase 1: plan every field.
const imperativeFlags: boolean[] = [];
- const planned = session.messages.map((m) => {
+ const planned = session.messages.map((m, i) => {
const imperative = IMPERATIVE_RES.some((re) => re.test(m.text));
imperativeFlags.push(imperative);
if (imperative) imperativesFlagged++;
// Speaker labels are persisted into the anchor line, so they get the
// same redaction as bodies (a secret or private name in a display name
// must not bypass the scan).
- return { m, text: plan(m.text), speaker: m.speaker ? plan(m.speaker) : undefined };
+ // Cross-message join: a label the previous message left dangling reads this message's first line as its value.
+ const leading = i > 0 ? trailingDanglingLabel(sanitizeForJsonb(session.messages[i - 1]!.text), TRANSCRIPT_LANE_SCAN_OPTS) : null;
+ return { m, text: plan(m.text, leading), speaker: m.speaker ? plan(m.speaker) : undefined };
});
const titlePlan = session.meta.title ? plan(session.meta.title) : undefined;
// Flatness is ENFORCED, not assumed: strings are planned; primitive
diff --git a/src/core/transcripts/secret-audit.ts b/src/core/transcripts/secret-audit.ts
index 51e3563415..7feff2d5d3 100644
--- a/src/core/transcripts/secret-audit.ts
+++ b/src/core/transcripts/secret-audit.ts
@@ -14,10 +14,10 @@
* order in small keyset batches.
*/
import type { BrainEngine } from '../engine.ts';
-import { scanText } from '../secret-scan.ts';
+import { TRANSCRIPT_LANE_SCAN_OPTS, scanText } from '../secret-scan.ts';
-/** Bump when the transcript-lane detectors change, so doctor asks for a fresh audit. */
-export const TRANSCRIPT_SECRET_AUDIT_VERSION = 5;
+/** Bump when the transcript-lane detectors change, so doctor asks for a fresh audit. 6: cookie_header, .netrc and the key-label join (GST-2768). */
+export const TRANSCRIPT_SECRET_AUDIT_VERSION = 6;
export const TRANSCRIPT_SECRET_AUDIT_KEY = 'transcripts.secret_audit';
const BATCH = 25;
const LINES_PER_PAGE = 20;
@@ -69,8 +69,8 @@ export async function auditTranscriptSecrets(
cursor = Number(row.id);
pagesScanned++;
const findings = [
- ...scanText(row.title ?? '', { highEntropy: true, labeledCredentials: true }).map((f) => ({ ...f, line: 0 })),
- ...scanText(row.compiled_truth ?? '', { highEntropy: true, labeledCredentials: true }),
+ ...scanText(row.title ?? '', TRANSCRIPT_LANE_SCAN_OPTS).map((f) => ({ ...f, line: 0 })),
+ ...scanText(row.compiled_truth ?? '', TRANSCRIPT_LANE_SCAN_OPTS),
];
if (findings.length === 0) continue;
const hits: Record<string, number> = {};
diff --git a/test/fixtures/transcripts/synthetic-credentials.shared-scanner.golden.json b/test/fixtures/transcripts/synthetic-credentials.shared-scanner.golden.json
new file mode 100644
index 0000000000..4b0b513b26
--- /dev/null
+++ b/test/fixtures/transcripts/synthetic-credentials.shared-scanner.golden.json
@@ -0,0 +1,4014 @@
+{
+ "default": {
+ "env-dump-ai-keys#0": {
+ "findings": [
+ [
+ "anthropic",
+ 2,
+ "sha256:023913f8eeb42379",
+ "fea180102e73eb32",
+ null
+ ],
+ [
+ "openai",
+ 3,
+ "sha256:9e0fb012d7c15759",
+ "59bcae474448e3d1",
+ null
+ ],
+ [
+ "voyage",
+ 4,
+ "sha256:923669e28cb4e398",
+ "363ec23ba95a4154",
+ null
+ ]
+ ],
+ "redacted": "987276c5be395a19"
+ },
+ "env-dump-ai-keys#joined": {
+ "findings": [
+ [
+ "anthropic",
+ 2,
+ "sha256:023913f8eeb42379",
+ "fea180102e73eb32",
+ null
+ ],
+ [
+ "openai",
+ 3,
+ "sha256:9e0fb012d7c15759",
+ "59bcae474448e3d1",
+ null
+ ],
+ [
+ "voyage",
+ 4,
+ "sha256:923669e28cb4e398",
+ "363ec23ba95a4154",
+ null
+ ]
+ ],
+ "redacted": "987276c5be395a19"
+ },
+ "env-openai#0": {
+ "findings": [
+ [
+ "openai",
+ 1,
+ "sha256:9e0fb012d7c15759",
+ "15ca035573fca82b",
+ null
+ ]
+ ],
+ "redacted": "15ca035573fca82b"
+ },
+ "env-openai#joined": {
+ "findings": [
+ [
+ "openai",
+ 1,
+ "sha256:9e0fb012d7c15759",
+ "15ca035573fca82b",
+ null
+ ]
+ ],
+ "redacted": "15ca035573fca82b"
+ },
+ "env-voyage#0": {
+ "findings": [
+ [
+ "voyage",
+ 1,
+ "sha256:923669e28cb4e398",
+ "363ec23ba95a4154",
+ null
+ ]
+ ],
+ "redacted": "363ec23ba95a4154"
+ },
+ "env-voyage#joined": {
+ "findings": [
+ [
+ "voyage",
+ 1,
+ "sha256:923669e28cb4e398",
+ "363ec23ba95a4154",
+ null
+ ]
+ ],
+ "redacted": "363ec23ba95a4154"
+ },
+ "env-dump-provider-keys#0": {
+ "findings": [
+ [
+ "openrouter",
+ 1,
+ "sha256:6f3fc1fd3a97c370",
+ "0537286877599fe8",
+ "0.60.502.0"
+ ],
+ [
+ "groq",
+ 2,
+ "sha256:9bb33382932a389a",
+ "1a5eef6683de2a71",
+ "0.60.502.0"
+ ],
+ [
+ "xai",
+ 3,
+ "sha256:f519e835b3cdf05a",
+ "dccdac9669d49e59",
+ "0.60.502.0"
+ ],
+ [
+ "perplexity",
+ 4,
+ "sha256:7d6fd87c1bd4f107",
+ "b292f94ec8ed3d61",
+ "0.60.502.0"
+ ],
+ [
+ "replicate",
+ 5,
+ "sha256:6b337b60ac216986",
+ "a53a9c1f28dc4f2f",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "7cb9fe5bdafa0380"
+ },
+ "env-dump-provider-keys#joined": {
+ "findings": [
+ [
+ "openrouter",
+ 1,
+ "sha256:6f3fc1fd3a97c370",
+ "0537286877599fe8",
+ "0.60.502.0"
+ ],
+ [
+ "groq",
+ 2,
+ "sha256:9bb33382932a389a",
+ "1a5eef6683de2a71",
+ "0.60.502.0"
+ ],
+ [
+ "xai",
+ 3,
+ "sha256:f519e835b3cdf05a",
+ "dccdac9669d49e59",
+ "0.60.502.0"
+ ],
+ [
+ "perplexity",
+ 4,
+ "sha256:7d6fd87c1bd4f107",
+ "b292f94ec8ed3d61",
+ "0.60.502.0"
+ ],
+ [
+ "replicate",
+ 5,
+ "sha256:6b337b60ac216986",
+ "a53a9c1f28dc4f2f",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "7cb9fe5bdafa0380"
+ },
+ "env-groq#0": {
+ "findings": [
+ [
+ "groq",
+ 1,
+ "sha256:9bb33382932a389a",
+ "1a5eef6683de2a71",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "1a5eef6683de2a71"
+ },
+ "env-groq#joined": {
+ "findings": [
+ [
+ "groq",
+ 1,
+ "sha256:9bb33382932a389a",
+ "1a5eef6683de2a71",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "1a5eef6683de2a71"
+ },
+ "env-xai#0": {
+ "findings": [
+ [
+ "xai",
+ 1,
+ "sha256:f519e835b3cdf05a",
+ "dccdac9669d49e59",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "dccdac9669d49e59"
+ },
+ "env-xai#joined": {
+ "findings": [
+ [
+ "xai",
+ 1,
+ "sha256:f519e835b3cdf05a",
+ "dccdac9669d49e59",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "dccdac9669d49e59"
+ },
+ "env-perplexity#0": {
+ "findings": [
+ [
+ "perplexity",
+ 1,
+ "sha256:7d6fd87c1bd4f107",
+ "b292f94ec8ed3d61",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "b292f94ec8ed3d61"
+ },
+ "env-perplexity#joined": {
+ "findings": [
+ [
+ "perplexity",
+ 1,
+ "sha256:7d6fd87c1bd4f107",
+ "b292f94ec8ed3d61",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "b292f94ec8ed3d61"
+ },
+ "env-replicate#0": {
+ "findings": [
+ [
+ "replicate",
+ 1,
+ "sha256:6b337b60ac216986",
+ "a53a9c1f28dc4f2f",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "a53a9c1f28dc4f2f"
+ },
+ "env-replicate#joined": {
+ "findings": [
+ [
+ "replicate",
+ 1,
+ "sha256:6b337b60ac216986",
+ "a53a9c1f28dc4f2f",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "a53a9c1f28dc4f2f"
+ },
+ "github-pat#0": {
+ "findings": [
+ [
+ "github_pat",
+ 1,
+ "sha256:a62fe51a20b4b1b6",
+ "4f97d23124db9835",
+ null
+ ]
+ ],
+ "redacted": "4f97d23124db9835"
+ },
+ "github-pat#joined": {
+ "findings": [
+ [
+ "github_pat",
+ 1,
+ "sha256:a62fe51a20b4b1b6",
+ "4f97d23124db9835",
+ null
+ ]
+ ],
+ "redacted": "4f97d23124db9835"
+ },
+ "env-github-token#0": {
+ "findings": [
+ [
+ "github_token",
+ 1,
+ "sha256:8834a5d5a0118aea",
+ "791d8838a3adc875",
+ null
+ ]
+ ],
+ "redacted": "791d8838a3adc875"
+ },
+ "env-github-token#joined": {
+ "findings": [
+ [
+ "github_token",
+ 1,
+ "sha256:8834a5d5a0118aea",
+ "791d8838a3adc875",
+ null
+ ]
+ ],
+ "redacted": "791d8838a3adc875"
+ },
+ "env-gitlab#0": {
+ "findings": [
+ [
+ "gitlab_pat",
+ 1,
+ "sha256:afa671dd897470c0",
+ "312620bbae01d289",
+ null
+ ]
+ ],
+ "redacted": "312620bbae01d289"
+ },
+ "env-gitlab#joined": {
+ "findings": [
+ [
+ "gitlab_pat",
+ 1,
+ "sha256:afa671dd897470c0",
+ "312620bbae01d289",
+ null
+ ]
+ ],
+ "redacted": "312620bbae01d289"
+ },
+ "chat-tokens#0": {
+ "findings": [
+ [
+ "slack",
+ 1,
+ "sha256:d7d06bcaa307a158",
+ "33cfe69f0492d2ea",
+ null
+ ],
+ [
+ "slack",
+ 1,
+ "sha256:2f7a9a64dc16288c",
+ "33cfe69f0492d2ea",
+ null
+ ]
+ ],
+ "redacted": "33cfe69f0492d2ea"
+ },
+ "chat-tokens#joined": {
+ "findings": [
+ [
+ "slack",
+ 1,
+ "sha256:d7d06bcaa307a158",
+ "33cfe69f0492d2ea",
+ null
+ ],
+ [
+ "slack",
+ 1,
+ "sha256:2f7a9a64dc16288c",
+ "33cfe69f0492d2ea",
+ null
+ ]
+ ],
+ "redacted": "33cfe69f0492d2ea"
+ },
+ "cloud-aws#0": {
+ "findings": [
+ [
+ "aws_access_key",
+ 2,
+ "sha256:a3d13cdfbf13028e",
+ "0b6f0bb71e505121",
+ null
+ ]
+ ],
+ "redacted": "90eaf53698476d17"
+ },
+ "cloud-aws#joined": {
+ "findings": [
+ [
+ "aws_access_key",
+ 2,
+ "sha256:a3d13cdfbf13028e",
+ "0b6f0bb71e505121",
+ null
+ ]
+ ],
+ "redacted": "90eaf53698476d17"
+ },
+ "cloud-google#0": {
+ "findings": [
+ [
+ "google_api_key",
+ 1,
+ "sha256:005d435bb16e204f",
+ "bb51f041f49b82b6",
+ null
+ ]
+ ],
+ "redacted": "bb51f041f49b82b6"
+ },
+ "cloud-google#joined": {
+ "findings": [
+ [
+ "google_api_key",
+ 1,
+ "sha256:005d435bb16e204f",
+ "bb51f041f49b82b6",
+ null
+ ]
+ ],
+ "redacted": "bb51f041f49b82b6"
+ },
+ "stripe-keys#0": {
+ "findings": [
+ [
+ "stripe",
+ 1,
+ "sha256:abeef5774c6493e0",
+ "803a594ced4f77a8",
+ null
+ ],
+ [
+ "stripe",
+ 2,
+ "sha256:ae1bcf651f22d1d8",
+ "da116bb48f7368dc",
+ null
+ ]
+ ],
+ "redacted": "5f13fadbc182c39d"
+ },
+ "stripe-keys#joined": {
+ "findings": [
+ [
+ "stripe",
+ 1,
+ "sha256:abeef5774c6493e0",
+ "803a594ced4f77a8",
+ null
+ ],
+ [
+ "stripe",
+ 2,
+ "sha256:ae1bcf651f22d1d8",
+ "da116bb48f7368dc",
+ null
+ ]
+ ],
+ "redacted": "5f13fadbc182c39d"
+ },
+ "sendgrid#0": {
+ "findings": [
+ [
+ "sendgrid",
+ 1,
+ "sha256:48c847e79d74f12c",
+ "f068d6b4b67b580a",
+ null
+ ]
+ ],
+ "redacted": "f068d6b4b67b580a"
+ },
+ "sendgrid#joined": {
+ "findings": [
+ [
+ "sendgrid",
+ 1,
+ "sha256:48c847e79d74f12c",
+ "f068d6b4b67b580a",
+ null
+ ]
+ ],
+ "redacted": "f068d6b4b67b580a"
+ },
+ "twilio#0": {
+ "findings": [
+ [
+ "twilio",
+ 1,
+ "sha256:b363ade84d56c43b",
+ "1e5763c415956bac",
+ null
+ ]
+ ],
+ "redacted": "1e5763c415956bac"
+ },
+ "twilio#joined": {
+ "findings": [
+ [
+ "twilio",
+ 1,
+ "sha256:b363ade84d56c43b",
+ "1e5763c415956bac",
+ null
+ ]
+ ],
+ "redacted": "1e5763c415956bac"
+ },
+ "supabase#0": {
+ "findings": [
+ [
+ "supabase_key",
+ 1,
+ "sha256:df9f2fed0b280eef",
+ "a45a626af1e5c3c5",
+ null
+ ],
+ [
+ "supabase_key",
+ 2,
+ "sha256:8246ef07a213a4d9",
+ "24031044052fb00b",
+ null
+ ]
+ ],
+ "redacted": "a75c7beb2122696c"
+ },
+ "supabase#joined": {
+ "findings": [
+ [
+ "supabase_key",
+ 1,
+ "sha256:df9f2fed0b280eef",
+ "a45a626af1e5c3c5",
+ null
+ ],
+ [
+ "supabase_key",
+ 2,
+ "sha256:8246ef07a213a4d9",
+ "24031044052fb00b",
+ null
+ ]
+ ],
+ "redacted": "a75c7beb2122696c"
+ },
+ "npmrc#0": {
+ "findings": [
+ [
+ "npm_token",
+ 1,
+ "sha256:7b370ae3d08eef8b",
+ "b1dc9a6c46b49690",
+ null
+ ]
+ ],
+ "redacted": "b1dc9a6c46b49690"
+ },
+ "npmrc#joined": {
+ "findings": [
+ [
+ "npm_token",
+ 1,
+ "sha256:7b370ae3d08eef8b",
+ "b1dc9a6c46b49690",
+ null
+ ]
+ ],
+ "redacted": "b1dc9a6c46b49690"
+ },
+ "huggingface#0": {
+ "findings": [
+ [
+ "huggingface",
+ 1,
+ "sha256:24d754fc36ced0a6",
+ "09634a2a8c712cb7",
+ null
+ ]
+ ],
+ "redacted": "09634a2a8c712cb7"
+ },
+ "huggingface#joined": {
+ "findings": [
+ [
+ "huggingface",
+ 1,
+ "sha256:24d754fc36ced0a6",
+ "09634a2a8c712cb7",
+ null
+ ]
+ ],
+ "redacted": "09634a2a8c712cb7"
+ },
+ "digitalocean#0": {
+ "findings": [
+ [
+ "digitalocean",
+ 1,
+ "sha256:9e4a4330bc71d7ac",
+ "ffbd7ee5a6e6f46e",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "ffbd7ee5a6e6f46e"
+ },
+ "digitalocean#joined": {
+ "findings": [
+ [
+ "digitalocean",
+ 1,
+ "sha256:9e4a4330bc71d7ac",
+ "ffbd7ee5a6e6f46e",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "ffbd7ee5a6e6f46e"
+ },
+ "gbrain-token#0": {
+ "findings": [
+ [
+ "gbrain_token",
+ 1,
+ "sha256:b6c4732b5b567235",
+ "27841e289ad29eb0",
+ null
+ ]
+ ],
+ "redacted": "27841e289ad29eb0"
+ },
+ "gbrain-token#joined": {
+ "findings": [
+ [
+ "gbrain_token",
+ 1,
+ "sha256:b6c4732b5b567235",
+ "27841e289ad29eb0",
+ null
+ ]
+ ],
+ "redacted": "27841e289ad29eb0"
+ },
+ "jwt#0": {
+ "findings": [
+ [
+ "jwt",
+ 1,
+ "sha256:4eb3833f048793cf",
+ "496eaa6fc37ab873",
+ null
+ ]
+ ],
+ "redacted": "496eaa6fc37ab873"
+ },
+ "jwt#joined": {
+ "findings": [
+ [
+ "jwt",
+ 1,
+ "sha256:4eb3833f048793cf",
+ "496eaa6fc37ab873",
+ null
+ ]
+ ],
+ "redacted": "496eaa6fc37ab873"
+ },
+ "curl-bearer#0": {
+ "findings": [
+ [
+ "bearer",
+ 1,
+ "sha256:ce77318a533b584c",
+ "6152f12a5d4241b2",
+ null
+ ]
+ ],
+ "redacted": "6152f12a5d4241b2"
+ },
+ "curl-bearer#joined": {
+ "findings": [
+ [
+ "bearer",
+ 1,
+ "sha256:ce77318a533b584c",
+ "6152f12a5d4241b2",
+ null
+ ]
+ ],
+ "redacted": "6152f12a5d4241b2"
+ },
+ "database-url#0": {
+ "findings": [
+ [
+ "db_url_credentials",
+ 1,
+ "sha256:c99d8e7f261fce8c",
+ "742691068b7f87ca",
+ null
+ ]
+ ],
+ "redacted": "742691068b7f87ca"
+ },
+ "database-url#joined": {
+ "findings": [
+ [
+ "db_url_credentials",
+ 1,
+ "sha256:c99d8e7f261fce8c",
+ "742691068b7f87ca",
+ null
+ ]
+ ],
+ "redacted": "742691068b7f87ca"
+ },
+ "git-url-credentials#0": {
+ "findings": [
+ [
+ "url_credentials",
+ 1,
+ "sha256:e71f032d4f3308ec",
+ "6bee57c8d7b67ed9",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "6bee57c8d7b67ed9"
+ },
+ "git-url-credentials#joined": {
+ "findings": [
+ [
+ "url_credentials",
+ 1,
+ "sha256:e71f032d4f3308ec",
+ "6bee57c8d7b67ed9",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "6bee57c8d7b67ed9"
+ },
+ "curl-basic#0": {
+ "findings": [
+ [
+ "basic_auth",
+ 1,
+ "sha256:773fe1da02bbcf94",
+ "52c43f87174d4c3e",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "52c43f87174d4c3e"
+ },
+ "curl-basic#joined": {
+ "findings": [
+ [
+ "basic_auth",
+ 1,
+ "sha256:773fe1da02bbcf94",
+ "52c43f87174d4c3e",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "52c43f87174d4c3e"
+ },
+ "pem-block#0": {
+ "findings": [
+ [
+ "private_key_pem",
+ 2,
+ "sha256:48f492fad8b2c504",
+ "96dffd8709b784ec",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "a699ad1bd3d6ea5a"
+ },
+ "pem-block#joined": {
+ "findings": [
+ [
+ "private_key_pem",
+ 2,
+ "sha256:48f492fad8b2c504",
+ "96dffd8709b784ec",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "a699ad1bd3d6ea5a"
+ },
+ "entropy-assignment#0": {
+ "findings": [],
+ "redacted": "9146075a5494d122"
+ },
+ "entropy-assignment#joined": {
+ "findings": [],
+ "redacted": "9146075a5494d122"
+ },
+ "json-password#0": {
+ "findings": [],
+ "redacted": "38ef1c34d926ce94"
+ },
+ "json-password#joined": {
+ "findings": [],
+ "redacted": "38ef1c34d926ce94"
+ },
+ "netrc-line#0": {
+ "findings": [],
+ "redacted": "26b379bcf151a445"
+ },
+ "netrc-line#joined": {
+ "findings": [],
+ "redacted": "26b379bcf151a445"
+ },
+ "login-pair#0": {
+ "findings": [],
+ "redacted": "7e6763e1f55a0bf5"
+ },
+ "login-pair#joined": {
+ "findings": [],
+ "redacted": "7e6763e1f55a0bf5"
+ },
+ "cli-password#0": {
+ "findings": [],
+ "redacted": "be9fffc561f454fa"
+ },
+ "cli-password#joined": {
+ "findings": [],
+ "redacted": "be9fffc561f454fa"
+ },
+ "cookie-curl-header#0": {
+ "findings": [],
+ "redacted": "3634e83f4feb027c"
+ },
+ "cookie-curl-header#joined": {
+ "findings": [],
+ "redacted": "3634e83f4feb027c"
+ },
+ "cookie-devtools#0": {
+ "findings": [],
+ "redacted": "5c9d1f29f3b1cf85"
+ },
+ "cookie-devtools#joined": {
+ "findings": [],
+ "redacted": "5c9d1f29f3b1cf85"
+ },
+ "set-cookie#0": {
+ "findings": [],
+ "redacted": "b62d689c3b146e3d"
+ },
+ "set-cookie#joined": {
+ "findings": [],
+ "redacted": "b62d689c3b146e3d"
+ },
+ "cookie-curl-b#0": {
+ "findings": [],
+ "redacted": "daf8440250be80b2"
+ },
+ "cookie-curl-b#joined": {
+ "findings": [],
+ "redacted": "daf8440250be80b2"
+ },
+ "cookie-fetch-json#0": {
+ "findings": [],
+ "redacted": "f007539fa76c3f9e"
+ },
+ "cookie-fetch-json#joined": {
+ "findings": [],
+ "redacted": "f007539fa76c3f9e"
+ },
+ "split-key-messages#0": {
+ "findings": [],
+ "redacted": "6162dbe5ff2e98fd"
+ },
+ "split-key-messages#1": {
+ "findings": [],
+ "redacted": "8984688825f36c25"
+ },
+ "split-key-messages#joined": {
+ "findings": [],
+ "redacted": "8f70201aea5ce999"
+ },
+ "split-password-messages#0": {
+ "findings": [],
+ "redacted": "c304787445ce7cab"
+ },
+ "split-password-messages#1": {
+ "findings": [],
+ "redacted": "d2b3f565dc3a4dc8"
+ },
+ "split-password-messages#joined": {
+ "findings": [],
+ "redacted": "0ee4d331d874d66d"
+ },
+ "split-pair-messages#0": {
+ "findings": [],
+ "redacted": "ce35f81b6ef6d5f1"
+ },
+ "split-pair-messages#1": {
+ "findings": [],
+ "redacted": "315959dd542ff5b3"
+ },
+ "split-pair-messages#joined": {
+ "findings": [],
+ "redacted": "08e5525c2b1e629c"
+ },
+ "split-token-lines#0": {
+ "findings": [],
+ "redacted": "7b0c6dfab13239ec"
+ },
+ "split-token-lines#joined": {
+ "findings": [],
+ "redacted": "7b0c6dfab13239ec"
+ },
+ "prose#0": {
+ "findings": [],
+ "redacted": "b70707f7c770dd8a"
+ },
+ "prose#1": {
+ "findings": [],
+ "redacted": "93d025a6d32e2f2b"
+ },
+ "prose#2": {
+ "findings": [],
+ "redacted": "92f10d223e427fb0"
+ },
+ "prose#3": {
+ "findings": [],
+ "redacted": "4979bc840e9ada2a"
+ },
+ "prose#4": {
+ "findings": [],
+ "redacted": "0a0f4a0c23870ccd"
+ },
+ "prose#5": {
+ "findings": [],
+ "redacted": "c3280915a02ee666"
+ },
+ "prose#6": {
+ "findings": [],
+ "redacted": "01e4aaa6cbd057ef"
+ },
+ "prose#7": {
+ "findings": [],
+ "redacted": "7626a58f28010212"
+ }
+ },
+ "highEntropy": {
+ "env-dump-ai-keys#0": {
+ "findings": [
+ [
+ "anthropic",
+ 2,
+ "sha256:023913f8eeb42379",
+ "fea180102e73eb32",
+ null
+ ],
+ [
+ "openai",
+ 3,
+ "sha256:9e0fb012d7c15759",
+ "59bcae474448e3d1",
+ null
+ ],
+ [
+ "voyage",
+ 4,
+ "sha256:923669e28cb4e398",
+ "363ec23ba95a4154",
+ null
+ ]
+ ],
+ "redacted": "987276c5be395a19"
+ },
+ "env-dump-ai-keys#joined": {
+ "findings": [
+ [
+ "anthropic",
+ 2,
+ "sha256:023913f8eeb42379",
+ "fea180102e73eb32",
+ null
+ ],
+ [
+ "openai",
+ 3,
+ "sha256:9e0fb012d7c15759",
+ "59bcae474448e3d1",
+ null
+ ],
+ [
+ "voyage",
+ 4,
+ "sha256:923669e28cb4e398",
+ "363ec23ba95a4154",
+ null
+ ]
+ ],
+ "redacted": "987276c5be395a19"
+ },
+ "env-openai#0": {
+ "findings": [
+ [
+ "openai",
+ 1,
+ "sha256:9e0fb012d7c15759",
+ "15ca035573fca82b",
+ null
+ ]
+ ],
+ "redacted": "15ca035573fca82b"
+ },
+ "env-openai#joined": {
+ "findings": [
+ [
+ "openai",
+ 1,
+ "sha256:9e0fb012d7c15759",
+ "15ca035573fca82b",
+ null
+ ]
+ ],
+ "redacted": "15ca035573fca82b"
+ },
+ "env-voyage#0": {
+ "findings": [
+ [
+ "voyage",
+ 1,
+ "sha256:923669e28cb4e398",
+ "363ec23ba95a4154",
+ null
+ ]
+ ],
+ "redacted": "363ec23ba95a4154"
+ },
+ "env-voyage#joined": {
+ "findings": [
+ [
+ "voyage",
+ 1,
+ "sha256:923669e28cb4e398",
+ "363ec23ba95a4154",
+ null
+ ]
+ ],
+ "redacted": "363ec23ba95a4154"
+ },
+ "env-dump-provider-keys#0": {
+ "findings": [
+ [
+ "openrouter",
+ 1,
+ "sha256:6f3fc1fd3a97c370",
+ "0537286877599fe8",
+ "0.60.502.0"
+ ],
+ [
+ "groq",
+ 2,
+ "sha256:9bb33382932a389a",
+ "1a5eef6683de2a71",
+ "0.60.502.0"
+ ],
+ [
+ "xai",
+ 3,
+ "sha256:f519e835b3cdf05a",
+ "dccdac9669d49e59",
+ "0.60.502.0"
+ ],
+ [
+ "perplexity",
+ 4,
+ "sha256:7d6fd87c1bd4f107",
+ "b292f94ec8ed3d61",
+ "0.60.502.0"
+ ],
+ [
+ "replicate",
+ 5,
+ "sha256:6b337b60ac216986",
+ "a53a9c1f28dc4f2f",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "7cb9fe5bdafa0380"
+ },
+ "env-dump-provider-keys#joined": {
+ "findings": [
+ [
+ "openrouter",
+ 1,
+ "sha256:6f3fc1fd3a97c370",
+ "0537286877599fe8",
+ "0.60.502.0"
+ ],
+ [
+ "groq",
+ 2,
+ "sha256:9bb33382932a389a",
+ "1a5eef6683de2a71",
+ "0.60.502.0"
+ ],
+ [
+ "xai",
+ 3,
+ "sha256:f519e835b3cdf05a",
+ "dccdac9669d49e59",
+ "0.60.502.0"
+ ],
+ [
+ "perplexity",
+ 4,
+ "sha256:7d6fd87c1bd4f107",
+ "b292f94ec8ed3d61",
+ "0.60.502.0"
+ ],
+ [
+ "replicate",
+ 5,
+ "sha256:6b337b60ac216986",
+ "a53a9c1f28dc4f2f",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "7cb9fe5bdafa0380"
+ },
+ "env-groq#0": {
+ "findings": [
+ [
+ "groq",
+ 1,
+ "sha256:9bb33382932a389a",
+ "1a5eef6683de2a71",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "1a5eef6683de2a71"
+ },
+ "env-groq#joined": {
+ "findings": [
+ [
+ "groq",
+ 1,
+ "sha256:9bb33382932a389a",
+ "1a5eef6683de2a71",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "1a5eef6683de2a71"
+ },
+ "env-xai#0": {
+ "findings": [
+ [
+ "xai",
+ 1,
+ "sha256:f519e835b3cdf05a",
+ "dccdac9669d49e59",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "dccdac9669d49e59"
+ },
+ "env-xai#joined": {
+ "findings": [
+ [
+ "xai",
+ 1,
+ "sha256:f519e835b3cdf05a",
+ "dccdac9669d49e59",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "dccdac9669d49e59"
+ },
+ "env-perplexity#0": {
+ "findings": [
+ [
+ "perplexity",
+ 1,
+ "sha256:7d6fd87c1bd4f107",
+ "b292f94ec8ed3d61",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "b292f94ec8ed3d61"
+ },
+ "env-perplexity#joined": {
+ "findings": [
+ [
+ "perplexity",
+ 1,
+ "sha256:7d6fd87c1bd4f107",
+ "b292f94ec8ed3d61",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "b292f94ec8ed3d61"
+ },
+ "env-replicate#0": {
+ "findings": [
+ [
+ "replicate",
+ 1,
+ "sha256:6b337b60ac216986",
+ "a53a9c1f28dc4f2f",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "a53a9c1f28dc4f2f"
+ },
+ "env-replicate#joined": {
+ "findings": [
+ [
+ "replicate",
+ 1,
+ "sha256:6b337b60ac216986",
+ "a53a9c1f28dc4f2f",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "a53a9c1f28dc4f2f"
+ },
+ "github-pat#0": {
+ "findings": [
+ [
+ "github_pat",
+ 1,
+ "sha256:a62fe51a20b4b1b6",
+ "4f97d23124db9835",
+ null
+ ]
+ ],
+ "redacted": "4f97d23124db9835"
+ },
+ "github-pat#joined": {
+ "findings": [
+ [
+ "github_pat",
+ 1,
+ "sha256:a62fe51a20b4b1b6",
+ "4f97d23124db9835",
+ null
+ ]
+ ],
+ "redacted": "4f97d23124db9835"
+ },
+ "env-github-token#0": {
+ "findings": [
+ [
+ "github_token",
+ 1,
+ "sha256:8834a5d5a0118aea",
+ "791d8838a3adc875",
+ null
+ ]
+ ],
+ "redacted": "791d8838a3adc875"
+ },
+ "env-github-token#joined": {
+ "findings": [
+ [
+ "github_token",
+ 1,
+ "sha256:8834a5d5a0118aea",
+ "791d8838a3adc875",
+ null
+ ]
+ ],
+ "redacted": "791d8838a3adc875"
+ },
+ "env-gitlab#0": {
+ "findings": [
+ [
+ "gitlab_pat",
+ 1,
+ "sha256:afa671dd897470c0",
+ "312620bbae01d289",
+ null
+ ]
+ ],
+ "redacted": "312620bbae01d289"
+ },
+ "env-gitlab#joined": {
+ "findings": [
+ [
+ "gitlab_pat",
+ 1,
+ "sha256:afa671dd897470c0",
+ "312620bbae01d289",
+ null
+ ]
+ ],
+ "redacted": "312620bbae01d289"
+ },
+ "chat-tokens#0": {
+ "findings": [
+ [
+ "slack",
+ 1,
+ "sha256:d7d06bcaa307a158",
+ "33cfe69f0492d2ea",
+ null
+ ],
+ [
+ "slack",
+ 1,
+ "sha256:2f7a9a64dc16288c",
+ "33cfe69f0492d2ea",
+ null
+ ]
+ ],
+ "redacted": "33cfe69f0492d2ea"
+ },
+ "chat-tokens#joined": {
+ "findings": [
+ [
+ "slack",
+ 1,
+ "sha256:d7d06bcaa307a158",
+ "33cfe69f0492d2ea",
+ null
+ ],
+ [
+ "slack",
+ 1,
+ "sha256:2f7a9a64dc16288c",
+ "33cfe69f0492d2ea",
+ null
+ ]
+ ],
+ "redacted": "33cfe69f0492d2ea"
+ },
+ "cloud-aws#0": {
+ "findings": [
+ [
+ "aws_access_key",
+ 2,
+ "sha256:a3d13cdfbf13028e",
+ "0b6f0bb71e505121",
+ null
+ ],
+ [
+ "high_entropy_assignment",
+ 3,
+ "sha256:e2aecdfb48e5cf9a",
+ "e02816c5504806ed",
+ null
+ ]
+ ],
+ "redacted": "06f6a80f1900e699"
+ },
+ "cloud-aws#joined": {
+ "findings": [
+ [
+ "aws_access_key",
+ 2,
+ "sha256:a3d13cdfbf13028e",
+ "0b6f0bb71e505121",
+ null
+ ],
+ [
+ "high_entropy_assignment",
+ 3,
+ "sha256:e2aecdfb48e5cf9a",
+ "e02816c5504806ed",
+ null
+ ]
+ ],
+ "redacted": "06f6a80f1900e699"
+ },
+ "cloud-google#0": {
+ "findings": [
+ [
+ "google_api_key",
+ 1,
+ "sha256:005d435bb16e204f",
+ "bb51f041f49b82b6",
+ null
+ ]
+ ],
+ "redacted": "bb51f041f49b82b6"
+ },
+ "cloud-google#joined": {
+ "findings": [
+ [
+ "google_api_key",
+ 1,
+ "sha256:005d435bb16e204f",
+ "bb51f041f49b82b6",
+ null
+ ]
+ ],
+ "redacted": "bb51f041f49b82b6"
+ },
+ "stripe-keys#0": {
+ "findings": [
+ [
+ "stripe",
+ 1,
+ "sha256:abeef5774c6493e0",
+ "803a594ced4f77a8",
+ null
+ ],
+ [
+ "stripe",
+ 2,
+ "sha256:ae1bcf651f22d1d8",
+ "da116bb48f7368dc",
+ null
+ ]
+ ],
+ "redacted": "5f13fadbc182c39d"
+ },
+ "stripe-keys#joined": {
+ "findings": [
+ [
+ "stripe",
+ 1,
+ "sha256:abeef5774c6493e0",
+ "803a594ced4f77a8",
+ null
+ ],
+ [
+ "stripe",
+ 2,
+ "sha256:ae1bcf651f22d1d8",
+ "da116bb48f7368dc",
+ null
+ ]
+ ],
+ "redacted": "5f13fadbc182c39d"
+ },
+ "sendgrid#0": {
+ "findings": [
+ [
+ "sendgrid",
+ 1,
+ "sha256:48c847e79d74f12c",
+ "f068d6b4b67b580a",
+ null
+ ]
+ ],
+ "redacted": "f068d6b4b67b580a"
+ },
+ "sendgrid#joined": {
+ "findings": [
+ [
+ "sendgrid",
+ 1,
+ "sha256:48c847e79d74f12c",
+ "f068d6b4b67b580a",
+ null
+ ]
+ ],
+ "redacted": "f068d6b4b67b580a"
+ },
+ "twilio#0": {
+ "findings": [
+ [
+ "twilio",
+ 1,
+ "sha256:b363ade84d56c43b",
+ "1e5763c415956bac",
+ null
+ ]
+ ],
+ "redacted": "1e5763c415956bac"
+ },
+ "twilio#joined": {
+ "findings": [
+ [
+ "twilio",
+ 1,
+ "sha256:b363ade84d56c43b",
+ "1e5763c415956bac",
+ null
+ ]
+ ],
+ "redacted": "1e5763c415956bac"
+ },
+ "supabase#0": {
+ "findings": [
+ [
+ "supabase_key",
+ 1,
+ "sha256:df9f2fed0b280eef",
+ "a45a626af1e5c3c5",
+ null
+ ],
+ [
+ "supabase_key",
+ 2,
+ "sha256:8246ef07a213a4d9",
+ "24031044052fb00b",
+ null
+ ]
+ ],
+ "redacted": "a75c7beb2122696c"
+ },
+ "supabase#joined": {
+ "findings": [
+ [
+ "supabase_key",
+ 1,
+ "sha256:df9f2fed0b280eef",
+ "a45a626af1e5c3c5",
+ null
+ ],
+ [
+ "supabase_key",
+ 2,
+ "sha256:8246ef07a213a4d9",
+ "24031044052fb00b",
+ null
+ ]
+ ],
+ "redacted": "a75c7beb2122696c"
+ },
+ "npmrc#0": {
+ "findings": [
+ [
+ "npm_token",
+ 1,
+ "sha256:7b370ae3d08eef8b",
+ "b1dc9a6c46b49690",
+ null
+ ]
+ ],
+ "redacted": "b1dc9a6c46b49690"
+ },
+ "npmrc#joined": {
+ "findings": [
+ [
+ "npm_token",
+ 1,
+ "sha256:7b370ae3d08eef8b",
+ "b1dc9a6c46b49690",
+ null
+ ]
+ ],
+ "redacted": "b1dc9a6c46b49690"
+ },
+ "huggingface#0": {
+ "findings": [
+ [
+ "huggingface",
+ 1,
+ "sha256:24d754fc36ced0a6",
+ "09634a2a8c712cb7",
+ null
+ ]
+ ],
+ "redacted": "09634a2a8c712cb7"
+ },
+ "huggingface#joined": {
+ "findings": [
+ [
+ "huggingface",
+ 1,
+ "sha256:24d754fc36ced0a6",
+ "09634a2a8c712cb7",
+ null
+ ]
+ ],
+ "redacted": "09634a2a8c712cb7"
+ },
+ "digitalocean#0": {
+ "findings": [
+ [
+ "digitalocean",
+ 1,
+ "sha256:9e4a4330bc71d7ac",
+ "ffbd7ee5a6e6f46e",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "ffbd7ee5a6e6f46e"
+ },
+ "digitalocean#joined": {
+ "findings": [
+ [
+ "digitalocean",
+ 1,
+ "sha256:9e4a4330bc71d7ac",
+ "ffbd7ee5a6e6f46e",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "ffbd7ee5a6e6f46e"
+ },
+ "gbrain-token#0": {
+ "findings": [
+ [
+ "gbrain_token",
+ 1,
+ "sha256:b6c4732b5b567235",
+ "27841e289ad29eb0",
+ null
+ ]
+ ],
+ "redacted": "27841e289ad29eb0"
+ },
+ "gbrain-token#joined": {
+ "findings": [
+ [
+ "gbrain_token",
+ 1,
+ "sha256:b6c4732b5b567235",
+ "27841e289ad29eb0",
+ null
+ ]
+ ],
+ "redacted": "27841e289ad29eb0"
+ },
+ "jwt#0": {
+ "findings": [
+ [
+ "jwt",
+ 1,
+ "sha256:4eb3833f048793cf",
+ "496eaa6fc37ab873",
+ null
+ ]
+ ],
+ "redacted": "496eaa6fc37ab873"
+ },
+ "jwt#joined": {
+ "findings": [
+ [
+ "jwt",
+ 1,
+ "sha256:4eb3833f048793cf",
+ "496eaa6fc37ab873",
+ null
+ ]
+ ],
+ "redacted": "496eaa6fc37ab873"
+ },
+ "curl-bearer#0": {
+ "findings": [
+ [
+ "bearer",
+ 1,
+ "sha256:ce77318a533b584c",
+ "6152f12a5d4241b2",
+ null
+ ]
+ ],
+ "redacted": "6152f12a5d4241b2"
+ },
+ "curl-bearer#joined": {
+ "findings": [
+ [
+ "bearer",
+ 1,
+ "sha256:ce77318a533b584c",
+ "6152f12a5d4241b2",
+ null
+ ]
+ ],
+ "redacted": "6152f12a5d4241b2"
+ },
+ "database-url#0": {
+ "findings": [
+ [
+ "db_url_credentials",
+ 1,
+ "sha256:c99d8e7f261fce8c",
+ "742691068b7f87ca",
+ null
+ ]
+ ],
+ "redacted": "742691068b7f87ca"
+ },
+ "database-url#joined": {
+ "findings": [
+ [
+ "db_url_credentials",
+ 1,
+ "sha256:c99d8e7f261fce8c",
+ "742691068b7f87ca",
+ null
+ ]
+ ],
+ "redacted": "742691068b7f87ca"
+ },
+ "git-url-credentials#0": {
+ "findings": [
+ [
+ "url_credentials",
+ 1,
+ "sha256:e71f032d4f3308ec",
+ "6bee57c8d7b67ed9",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "6bee57c8d7b67ed9"
+ },
+ "git-url-credentials#joined": {
+ "findings": [
+ [
+ "url_credentials",
+ 1,
+ "sha256:e71f032d4f3308ec",
+ "6bee57c8d7b67ed9",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "6bee57c8d7b67ed9"
+ },
+ "curl-basic#0": {
+ "findings": [
+ [
+ "basic_auth",
+ 1,
+ "sha256:773fe1da02bbcf94",
+ "52c43f87174d4c3e",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "52c43f87174d4c3e"
+ },
+ "curl-basic#joined": {
+ "findings": [
+ [
+ "basic_auth",
+ 1,
+ "sha256:773fe1da02bbcf94",
+ "52c43f87174d4c3e",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "52c43f87174d4c3e"
+ },
+ "pem-block#0": {
+ "findings": [
+ [
+ "private_key_pem",
+ 2,
+ "sha256:48f492fad8b2c504",
+ "96dffd8709b784ec",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "a699ad1bd3d6ea5a"
+ },
+ "pem-block#joined": {
+ "findings": [
+ [
+ "private_key_pem",
+ 2,
+ "sha256:48f492fad8b2c504",
+ "96dffd8709b784ec",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "a699ad1bd3d6ea5a"
+ },
+ "entropy-assignment#0": {
+ "findings": [
+ [
+ "high_entropy_assignment",
+ 1,
+ "sha256:e2aecdfb48e5cf9a",
+ "5378a25e9f4cd764",
+ null
+ ]
+ ],
+ "redacted": "5378a25e9f4cd764"
+ },
+ "entropy-assignment#joined": {
+ "findings": [
+ [
+ "high_entropy_assignment",
+ 1,
+ "sha256:e2aecdfb48e5cf9a",
+ "5378a25e9f4cd764",
+ null
+ ]
+ ],
+ "redacted": "5378a25e9f4cd764"
+ },
+ "json-password#0": {
+ "findings": [],
+ "redacted": "38ef1c34d926ce94"
+ },
+ "json-password#joined": {
+ "findings": [],
+ "redacted": "38ef1c34d926ce94"
+ },
+ "netrc-line#0": {
+ "findings": [],
+ "redacted": "26b379bcf151a445"
+ },
+ "netrc-line#joined": {
+ "findings": [],
+ "redacted": "26b379bcf151a445"
+ },
+ "login-pair#0": {
+ "findings": [],
+ "redacted": "7e6763e1f55a0bf5"
+ },
+ "login-pair#joined": {
+ "findings": [],
+ "redacted": "7e6763e1f55a0bf5"
+ },
+ "cli-password#0": {
+ "findings": [],
+ "redacted": "be9fffc561f454fa"
+ },
+ "cli-password#joined": {
+ "findings": [],
+ "redacted": "be9fffc561f454fa"
+ },
+ "cookie-curl-header#0": {
+ "findings": [],
+ "redacted": "3634e83f4feb027c"
+ },
+ "cookie-curl-header#joined": {
+ "findings": [],
+ "redacted": "3634e83f4feb027c"
+ },
+ "cookie-devtools#0": {
+ "findings": [],
+ "redacted": "5c9d1f29f3b1cf85"
+ },
+ "cookie-devtools#joined": {
+ "findings": [],
+ "redacted": "5c9d1f29f3b1cf85"
+ },
+ "set-cookie#0": {
+ "findings": [],
+ "redacted": "b62d689c3b146e3d"
+ },
+ "set-cookie#joined": {
+ "findings": [],
+ "redacted": "b62d689c3b146e3d"
+ },
+ "cookie-curl-b#0": {
+ "findings": [],
+ "redacted": "daf8440250be80b2"
+ },
+ "cookie-curl-b#joined": {
+ "findings": [],
+ "redacted": "daf8440250be80b2"
+ },
+ "cookie-fetch-json#0": {
+ "findings": [],
+ "redacted": "f007539fa76c3f9e"
+ },
+ "cookie-fetch-json#joined": {
+ "findings": [],
+ "redacted": "f007539fa76c3f9e"
+ },
+ "split-key-messages#0": {
+ "findings": [],
+ "redacted": "6162dbe5ff2e98fd"
+ },
+ "split-key-messages#1": {
+ "findings": [],
+ "redacted": "8984688825f36c25"
+ },
+ "split-key-messages#joined": {
+ "findings": [],
+ "redacted": "8f70201aea5ce999"
+ },
+ "split-password-messages#0": {
+ "findings": [],
+ "redacted": "c304787445ce7cab"
+ },
+ "split-password-messages#1": {
+ "findings": [],
+ "redacted": "d2b3f565dc3a4dc8"
+ },
+ "split-password-messages#joined": {
+ "findings": [],
+ "redacted": "0ee4d331d874d66d"
+ },
+ "split-pair-messages#0": {
+ "findings": [],
+ "redacted": "ce35f81b6ef6d5f1"
+ },
+ "split-pair-messages#1": {
+ "findings": [],
+ "redacted": "315959dd542ff5b3"
+ },
+ "split-pair-messages#joined": {
+ "findings": [],
+ "redacted": "08e5525c2b1e629c"
+ },
+ "split-token-lines#0": {
+ "findings": [],
+ "redacted": "7b0c6dfab13239ec"
+ },
+ "split-token-lines#joined": {
+ "findings": [],
+ "redacted": "7b0c6dfab13239ec"
+ },
+ "prose#0": {
+ "findings": [],
+ "redacted": "b70707f7c770dd8a"
+ },
+ "prose#1": {
+ "findings": [],
+ "redacted": "93d025a6d32e2f2b"
+ },
+ "prose#2": {
+ "findings": [],
+ "redacted": "92f10d223e427fb0"
+ },
+ "prose#3": {
+ "findings": [],
+ "redacted": "4979bc840e9ada2a"
+ },
+ "prose#4": {
+ "findings": [],
+ "redacted": "0a0f4a0c23870ccd"
+ },
+ "prose#5": {
+ "findings": [],
+ "redacted": "c3280915a02ee666"
+ },
+ "prose#6": {
+ "findings": [],
+ "redacted": "01e4aaa6cbd057ef"
+ },
+ "prose#7": {
+ "findings": [],
+ "redacted": "7626a58f28010212"
+ }
+ },
+ "labeledCredentials": {
+ "env-dump-ai-keys#0": {
+ "findings": [
+ [
+ "anthropic",
+ 2,
+ "sha256:023913f8eeb42379",
+ "fea180102e73eb32",
+ null
+ ],
+ [
+ "openai",
+ 3,
+ "sha256:9e0fb012d7c15759",
+ "59bcae474448e3d1",
+ null
+ ],
+ [
+ "voyage",
+ 4,
+ "sha256:923669e28cb4e398",
+ "363ec23ba95a4154",
+ null
+ ]
+ ],
+ "redacted": "987276c5be395a19"
+ },
+ "env-dump-ai-keys#joined": {
+ "findings": [
+ [
+ "anthropic",
+ 2,
+ "sha256:023913f8eeb42379",
+ "fea180102e73eb32",
+ null
+ ],
+ [
+ "openai",
+ 3,
+ "sha256:9e0fb012d7c15759",
+ "59bcae474448e3d1",
+ null
+ ],
+ [
+ "voyage",
+ 4,
+ "sha256:923669e28cb4e398",
+ "363ec23ba95a4154",
+ null
+ ]
+ ],
+ "redacted": "987276c5be395a19"
+ },
+ "env-openai#0": {
+ "findings": [
+ [
+ "openai",
+ 1,
+ "sha256:9e0fb012d7c15759",
+ "15ca035573fca82b",
+ null
+ ]
+ ],
+ "redacted": "15ca035573fca82b"
+ },
+ "env-openai#joined": {
+ "findings": [
+ [
+ "openai",
+ 1,
+ "sha256:9e0fb012d7c15759",
+ "15ca035573fca82b",
+ null
+ ]
+ ],
+ "redacted": "15ca035573fca82b"
+ },
+ "env-voyage#0": {
+ "findings": [
+ [
+ "voyage",
+ 1,
+ "sha256:923669e28cb4e398",
+ "363ec23ba95a4154",
+ null
+ ]
+ ],
+ "redacted": "363ec23ba95a4154"
+ },
+ "env-voyage#joined": {
+ "findings": [
+ [
+ "voyage",
+ 1,
+ "sha256:923669e28cb4e398",
+ "363ec23ba95a4154",
+ null
+ ]
+ ],
+ "redacted": "363ec23ba95a4154"
+ },
+ "env-dump-provider-keys#0": {
+ "findings": [
+ [
+ "openrouter",
+ 1,
+ "sha256:6f3fc1fd3a97c370",
+ "0537286877599fe8",
+ "0.60.502.0"
+ ],
+ [
+ "groq",
+ 2,
+ "sha256:9bb33382932a389a",
+ "1a5eef6683de2a71",
+ "0.60.502.0"
+ ],
+ [
+ "xai",
+ 3,
+ "sha256:f519e835b3cdf05a",
+ "dccdac9669d49e59",
+ "0.60.502.0"
+ ],
+ [
+ "perplexity",
+ 4,
+ "sha256:7d6fd87c1bd4f107",
+ "b292f94ec8ed3d61",
+ "0.60.502.0"
+ ],
+ [
+ "replicate",
+ 5,
+ "sha256:6b337b60ac216986",
+ "a53a9c1f28dc4f2f",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "7cb9fe5bdafa0380"
+ },
+ "env-dump-provider-keys#joined": {
+ "findings": [
+ [
+ "openrouter",
+ 1,
+ "sha256:6f3fc1fd3a97c370",
+ "0537286877599fe8",
+ "0.60.502.0"
+ ],
+ [
+ "groq",
+ 2,
+ "sha256:9bb33382932a389a",
+ "1a5eef6683de2a71",
+ "0.60.502.0"
+ ],
+ [
+ "xai",
+ 3,
+ "sha256:f519e835b3cdf05a",
+ "dccdac9669d49e59",
+ "0.60.502.0"
+ ],
+ [
+ "perplexity",
+ 4,
+ "sha256:7d6fd87c1bd4f107",
+ "b292f94ec8ed3d61",
+ "0.60.502.0"
+ ],
+ [
+ "replicate",
+ 5,
+ "sha256:6b337b60ac216986",
+ "a53a9c1f28dc4f2f",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "7cb9fe5bdafa0380"
+ },
+ "env-groq#0": {
+ "findings": [
+ [
+ "groq",
+ 1,
+ "sha256:9bb33382932a389a",
+ "1a5eef6683de2a71",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "1a5eef6683de2a71"
+ },
+ "env-groq#joined": {
+ "findings": [
+ [
+ "groq",
+ 1,
+ "sha256:9bb33382932a389a",
+ "1a5eef6683de2a71",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "1a5eef6683de2a71"
+ },
+ "env-xai#0": {
+ "findings": [
+ [
+ "xai",
+ 1,
+ "sha256:f519e835b3cdf05a",
+ "dccdac9669d49e59",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "dccdac9669d49e59"
+ },
+ "env-xai#joined": {
+ "findings": [
+ [
+ "xai",
+ 1,
+ "sha256:f519e835b3cdf05a",
+ "dccdac9669d49e59",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "dccdac9669d49e59"
+ },
+ "env-perplexity#0": {
+ "findings": [
+ [
+ "perplexity",
+ 1,
+ "sha256:7d6fd87c1bd4f107",
+ "b292f94ec8ed3d61",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "b292f94ec8ed3d61"
+ },
+ "env-perplexity#joined": {
+ "findings": [
+ [
+ "perplexity",
+ 1,
+ "sha256:7d6fd87c1bd4f107",
+ "b292f94ec8ed3d61",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "b292f94ec8ed3d61"
+ },
+ "env-replicate#0": {
+ "findings": [
+ [
+ "replicate",
+ 1,
+ "sha256:6b337b60ac216986",
+ "a53a9c1f28dc4f2f",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "a53a9c1f28dc4f2f"
+ },
+ "env-replicate#joined": {
+ "findings": [
+ [
+ "replicate",
+ 1,
+ "sha256:6b337b60ac216986",
+ "a53a9c1f28dc4f2f",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "a53a9c1f28dc4f2f"
+ },
+ "github-pat#0": {
+ "findings": [
+ [
+ "github_pat",
+ 1,
+ "sha256:a62fe51a20b4b1b6",
+ "4f97d23124db9835",
+ null
+ ]
+ ],
+ "redacted": "4f97d23124db9835"
+ },
+ "github-pat#joined": {
+ "findings": [
+ [
+ "github_pat",
+ 1,
+ "sha256:a62fe51a20b4b1b6",
+ "4f97d23124db9835",
+ null
+ ]
+ ],
+ "redacted": "4f97d23124db9835"
+ },
+ "env-github-token#0": {
+ "findings": [
+ [
+ "github_token",
+ 1,
+ "sha256:8834a5d5a0118aea",
+ "791d8838a3adc875",
+ null
+ ]
+ ],
+ "redacted": "791d8838a3adc875"
+ },
+ "env-github-token#joined": {
+ "findings": [
+ [
+ "github_token",
+ 1,
+ "sha256:8834a5d5a0118aea",
+ "791d8838a3adc875",
+ null
+ ]
+ ],
+ "redacted": "791d8838a3adc875"
+ },
+ "env-gitlab#0": {
+ "findings": [
+ [
+ "gitlab_pat",
+ 1,
+ "sha256:afa671dd897470c0",
+ "312620bbae01d289",
+ null
+ ]
+ ],
+ "redacted": "312620bbae01d289"
+ },
+ "env-gitlab#joined": {
+ "findings": [
+ [
+ "gitlab_pat",
+ 1,
+ "sha256:afa671dd897470c0",
+ "312620bbae01d289",
+ null
+ ]
+ ],
+ "redacted": "312620bbae01d289"
+ },
+ "chat-tokens#0": {
+ "findings": [
+ [
+ "slack",
+ 1,
+ "sha256:d7d06bcaa307a158",
+ "33cfe69f0492d2ea",
+ null
+ ],
+ [
+ "slack",
+ 1,
+ "sha256:2f7a9a64dc16288c",
+ "33cfe69f0492d2ea",
+ null
+ ]
+ ],
+ "redacted": "33cfe69f0492d2ea"
+ },
+ "chat-tokens#joined": {
+ "findings": [
+ [
+ "slack",
+ 1,
+ "sha256:d7d06bcaa307a158",
+ "33cfe69f0492d2ea",
+ null
+ ],
+ [
+ "slack",
+ 1,
+ "sha256:2f7a9a64dc16288c",
+ "33cfe69f0492d2ea",
+ null
+ ]
+ ],
+ "redacted": "33cfe69f0492d2ea"
+ },
+ "cloud-aws#0": {
+ "findings": [
+ [
+ "aws_access_key",
+ 2,
+ "sha256:a3d13cdfbf13028e",
+ "0b6f0bb71e505121",
+ null
+ ]
+ ],
+ "redacted": "90eaf53698476d17"
+ },
+ "cloud-aws#joined": {
+ "findings": [
+ [
+ "aws_access_key",
+ 2,
+ "sha256:a3d13cdfbf13028e",
+ "0b6f0bb71e505121",
+ null
+ ]
+ ],
+ "redacted": "90eaf53698476d17"
+ },
+ "cloud-google#0": {
+ "findings": [
+ [
+ "google_api_key",
+ 1,
+ "sha256:005d435bb16e204f",
+ "bb51f041f49b82b6",
+ null
+ ]
+ ],
+ "redacted": "bb51f041f49b82b6"
+ },
+ "cloud-google#joined": {
+ "findings": [
+ [
+ "google_api_key",
+ 1,
+ "sha256:005d435bb16e204f",
+ "bb51f041f49b82b6",
+ null
+ ]
+ ],
+ "redacted": "bb51f041f49b82b6"
+ },
+ "stripe-keys#0": {
+ "findings": [
+ [
+ "stripe",
+ 1,
+ "sha256:abeef5774c6493e0",
+ "803a594ced4f77a8",
+ null
+ ],
+ [
+ "stripe",
+ 2,
+ "sha256:ae1bcf651f22d1d8",
+ "da116bb48f7368dc",
+ null
+ ]
+ ],
+ "redacted": "5f13fadbc182c39d"
+ },
+ "stripe-keys#joined": {
+ "findings": [
+ [
+ "stripe",
+ 1,
+ "sha256:abeef5774c6493e0",
+ "803a594ced4f77a8",
+ null
+ ],
+ [
+ "stripe",
+ 2,
+ "sha256:ae1bcf651f22d1d8",
+ "da116bb48f7368dc",
+ null
+ ]
+ ],
+ "redacted": "5f13fadbc182c39d"
+ },
+ "sendgrid#0": {
+ "findings": [
+ [
+ "sendgrid",
+ 1,
+ "sha256:48c847e79d74f12c",
+ "f068d6b4b67b580a",
+ null
+ ]
+ ],
+ "redacted": "f068d6b4b67b580a"
+ },
+ "sendgrid#joined": {
+ "findings": [
+ [
+ "sendgrid",
+ 1,
+ "sha256:48c847e79d74f12c",
+ "f068d6b4b67b580a",
+ null
+ ]
+ ],
+ "redacted": "f068d6b4b67b580a"
+ },
+ "twilio#0": {
+ "findings": [
+ [
+ "twilio",
+ 1,
+ "sha256:b363ade84d56c43b",
+ "1e5763c415956bac",
+ null
+ ]
+ ],
+ "redacted": "1e5763c415956bac"
+ },
+ "twilio#joined": {
+ "findings": [
+ [
+ "twilio",
+ 1,
+ "sha256:b363ade84d56c43b",
+ "1e5763c415956bac",
+ null
+ ]
+ ],
+ "redacted": "1e5763c415956bac"
+ },
+ "supabase#0": {
+ "findings": [
+ [
+ "supabase_key",
+ 1,
+ "sha256:df9f2fed0b280eef",
+ "a45a626af1e5c3c5",
+ null
+ ],
+ [
+ "supabase_key",
+ 2,
+ "sha256:8246ef07a213a4d9",
+ "24031044052fb00b",
+ null
+ ]
+ ],
+ "redacted": "a75c7beb2122696c"
+ },
+ "supabase#joined": {
+ "findings": [
+ [
+ "supabase_key",
+ 1,
+ "sha256:df9f2fed0b280eef",
+ "a45a626af1e5c3c5",
+ null
+ ],
+ [
+ "supabase_key",
+ 2,
+ "sha256:8246ef07a213a4d9",
+ "24031044052fb00b",
+ null
+ ]
+ ],
+ "redacted": "a75c7beb2122696c"
+ },
+ "npmrc#0": {
+ "findings": [
+ [
+ "npm_token",
+ 1,
+ "sha256:7b370ae3d08eef8b",
+ "b1dc9a6c46b49690",
+ null
+ ]
+ ],
+ "redacted": "b1dc9a6c46b49690"
+ },
+ "npmrc#joined": {
+ "findings": [
+ [
+ "npm_token",
+ 1,
+ "sha256:7b370ae3d08eef8b",
+ "b1dc9a6c46b49690",
+ null
+ ]
+ ],
+ "redacted": "b1dc9a6c46b49690"
+ },
+ "huggingface#0": {
+ "findings": [
+ [
+ "huggingface",
+ 1,
+ "sha256:24d754fc36ced0a6",
+ "09634a2a8c712cb7",
+ null
+ ]
+ ],
+ "redacted": "09634a2a8c712cb7"
+ },
+ "huggingface#joined": {
+ "findings": [
+ [
+ "huggingface",
+ 1,
+ "sha256:24d754fc36ced0a6",
+ "09634a2a8c712cb7",
+ null
+ ]
+ ],
+ "redacted": "09634a2a8c712cb7"
+ },
+ "digitalocean#0": {
+ "findings": [
+ [
+ "digitalocean",
+ 1,
+ "sha256:9e4a4330bc71d7ac",
+ "ffbd7ee5a6e6f46e",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "ffbd7ee5a6e6f46e"
+ },
+ "digitalocean#joined": {
+ "findings": [
+ [
+ "digitalocean",
+ 1,
+ "sha256:9e4a4330bc71d7ac",
+ "ffbd7ee5a6e6f46e",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "ffbd7ee5a6e6f46e"
+ },
+ "gbrain-token#0": {
+ "findings": [
+ [
+ "gbrain_token",
+ 1,
+ "sha256:b6c4732b5b567235",
+ "27841e289ad29eb0",
+ null
+ ]
+ ],
+ "redacted": "27841e289ad29eb0"
+ },
+ "gbrain-token#joined": {
+ "findings": [
+ [
+ "gbrain_token",
+ 1,
+ "sha256:b6c4732b5b567235",
+ "27841e289ad29eb0",
+ null
+ ]
+ ],
+ "redacted": "27841e289ad29eb0"
+ },
+ "jwt#0": {
+ "findings": [
+ [
+ "jwt",
+ 1,
+ "sha256:4eb3833f048793cf",
+ "496eaa6fc37ab873",
+ null
+ ]
+ ],
+ "redacted": "496eaa6fc37ab873"
+ },
+ "jwt#joined": {
+ "findings": [
+ [
+ "jwt",
+ 1,
+ "sha256:4eb3833f048793cf",
+ "496eaa6fc37ab873",
+ null
+ ]
+ ],
+ "redacted": "496eaa6fc37ab873"
+ },
+ "curl-bearer#0": {
+ "findings": [
+ [
+ "bearer",
+ 1,
+ "sha256:ce77318a533b584c",
+ "6152f12a5d4241b2",
+ null
+ ]
+ ],
+ "redacted": "6152f12a5d4241b2"
+ },
+ "curl-bearer#joined": {
+ "findings": [
+ [
+ "bearer",
+ 1,
+ "sha256:ce77318a533b584c",
+ "6152f12a5d4241b2",
+ null
+ ]
+ ],
+ "redacted": "6152f12a5d4241b2"
+ },
+ "database-url#0": {
+ "findings": [
+ [
+ "db_url_credentials",
+ 1,
+ "sha256:c99d8e7f261fce8c",
+ "742691068b7f87ca",
+ null
+ ]
+ ],
+ "redacted": "742691068b7f87ca"
+ },
+ "database-url#joined": {
+ "findings": [
+ [
+ "db_url_credentials",
+ 1,
+ "sha256:c99d8e7f261fce8c",
+ "742691068b7f87ca",
+ null
+ ]
+ ],
+ "redacted": "742691068b7f87ca"
+ },
+ "git-url-credentials#0": {
+ "findings": [
+ [
+ "url_credentials",
+ 1,
+ "sha256:e71f032d4f3308ec",
+ "6bee57c8d7b67ed9",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "6bee57c8d7b67ed9"
+ },
+ "git-url-credentials#joined": {
+ "findings": [
+ [
+ "url_credentials",
+ 1,
+ "sha256:e71f032d4f3308ec",
+ "6bee57c8d7b67ed9",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "6bee57c8d7b67ed9"
+ },
+ "curl-basic#0": {
+ "findings": [
+ [
+ "basic_auth",
+ 1,
+ "sha256:773fe1da02bbcf94",
+ "52c43f87174d4c3e",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "52c43f87174d4c3e"
+ },
+ "curl-basic#joined": {
+ "findings": [
+ [
+ "basic_auth",
+ 1,
+ "sha256:773fe1da02bbcf94",
+ "52c43f87174d4c3e",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "52c43f87174d4c3e"
+ },
+ "pem-block#0": {
+ "findings": [
+ [
+ "private_key_pem",
+ 2,
+ "sha256:48f492fad8b2c504",
+ "96dffd8709b784ec",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "a699ad1bd3d6ea5a"
+ },
+ "pem-block#joined": {
+ "findings": [
+ [
+ "private_key_pem",
+ 2,
+ "sha256:48f492fad8b2c504",
+ "96dffd8709b784ec",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "a699ad1bd3d6ea5a"
+ },
+ "entropy-assignment#0": {
+ "findings": [],
+ "redacted": "9146075a5494d122"
+ },
+ "entropy-assignment#joined": {
+ "findings": [],
+ "redacted": "9146075a5494d122"
+ },
+ "json-password#0": {
+ "findings": [
+ [
+ "labeled_credential",
+ 1,
+ "sha256:ffb61cb3778b0ddf",
+ "04199d9df56f337e",
+ null
+ ]
+ ],
+ "redacted": "04199d9df56f337e"
+ },
+ "json-password#joined": {
+ "findings": [
+ [
+ "labeled_credential",
+ 1,
+ "sha256:ffb61cb3778b0ddf",
+ "04199d9df56f337e",
+ null
+ ]
+ ],
+ "redacted": "04199d9df56f337e"
+ },
+ "netrc-line#0": {
+ "findings": [],
+ "redacted": "26b379bcf151a445"
+ },
+ "netrc-line#joined": {
+ "findings": [],
+ "redacted": "26b379bcf151a445"
+ },
+ "login-pair#0": {
+ "findings": [
+ [
+ "labeled_credential",
+ 1,
+ "sha256:8cb8a16451d5472d",
+ "1364dc10c77ad192",
+ null
+ ]
+ ],
+ "redacted": "1364dc10c77ad192"
+ },
+ "login-pair#joined": {
+ "findings": [
+ [
+ "labeled_credential",
+ 1,
+ "sha256:8cb8a16451d5472d",
+ "1364dc10c77ad192",
+ null
+ ]
+ ],
+ "redacted": "1364dc10c77ad192"
+ },
+ "cli-password#0": {
+ "findings": [
+ [
+ "labeled_credential",
+ 1,
+ "sha256:c82f41fe9a8478ff",
+ "a9e6055c692f978d",
+ null
+ ]
+ ],
+ "redacted": "a9e6055c692f978d"
+ },
+ "cli-password#joined": {
+ "findings": [
+ [
+ "labeled_credential",
+ 1,
+ "sha256:c82f41fe9a8478ff",
+ "a9e6055c692f978d",
+ null
+ ]
+ ],
+ "redacted": "a9e6055c692f978d"
+ },
+ "cookie-curl-header#0": {
+ "findings": [],
+ "redacted": "3634e83f4feb027c"
+ },
+ "cookie-curl-header#joined": {
+ "findings": [],
+ "redacted": "3634e83f4feb027c"
+ },
+ "cookie-devtools#0": {
+ "findings": [],
+ "redacted": "5c9d1f29f3b1cf85"
+ },
+ "cookie-devtools#joined": {
+ "findings": [],
+ "redacted": "5c9d1f29f3b1cf85"
+ },
+ "set-cookie#0": {
+ "findings": [],
+ "redacted": "b62d689c3b146e3d"
+ },
+ "set-cookie#joined": {
+ "findings": [],
+ "redacted": "b62d689c3b146e3d"
+ },
+ "cookie-curl-b#0": {
+ "findings": [],
+ "redacted": "daf8440250be80b2"
+ },
+ "cookie-curl-b#joined": {
+ "findings": [],
+ "redacted": "daf8440250be80b2"
+ },
+ "cookie-fetch-json#0": {
+ "findings": [],
+ "redacted": "f007539fa76c3f9e"
+ },
+ "cookie-fetch-json#joined": {
+ "findings": [],
+ "redacted": "f007539fa76c3f9e"
+ },
+ "split-key-messages#0": {
+ "findings": [],
+ "redacted": "6162dbe5ff2e98fd"
+ },
+ "split-key-messages#1": {
+ "findings": [],
+ "redacted": "8984688825f36c25"
+ },
+ "split-key-messages#joined": {
+ "findings": [],
+ "redacted": "8f70201aea5ce999"
+ },
+ "split-password-messages#0": {
+ "findings": [],
+ "redacted": "c304787445ce7cab"
+ },
+ "split-password-messages#1": {
+ "findings": [],
+ "redacted": "d2b3f565dc3a4dc8"
+ },
+ "split-password-messages#joined": {
+ "findings": [
+ [
+ "labeled_credential",
+ 2,
+ "sha256:d2b3f565dc3a4dc8",
+ "3865e05eba46b7bb",
+ null
+ ]
+ ],
+ "redacted": "a8e7eec6823d7cf0"
+ },
+ "split-pair-messages#0": {
+ "findings": [],
+ "redacted": "ce35f81b6ef6d5f1"
+ },
+ "split-pair-messages#1": {
+ "findings": [],
+ "redacted": "315959dd542ff5b3"
+ },
+ "split-pair-messages#joined": {
+ "findings": [
+ [
+ "labeled_credential",
+ 2,
+ "sha256:139ec225a736f550",
+ "64be9e14023db3a3",
+ null
+ ]
+ ],
+ "redacted": "91bf0b2a6b1c7832"
+ },
+ "split-token-lines#0": {
+ "findings": [],
+ "redacted": "7b0c6dfab13239ec"
+ },
+ "split-token-lines#joined": {
+ "findings": [],
+ "redacted": "7b0c6dfab13239ec"
+ },
+ "prose#0": {
+ "findings": [],
+ "redacted": "b70707f7c770dd8a"
+ },
+ "prose#1": {
+ "findings": [],
+ "redacted": "93d025a6d32e2f2b"
+ },
+ "prose#2": {
+ "findings": [],
+ "redacted": "92f10d223e427fb0"
+ },
+ "prose#3": {
+ "findings": [],
+ "redacted": "4979bc840e9ada2a"
+ },
+ "prose#4": {
+ "findings": [],
+ "redacted": "0a0f4a0c23870ccd"
+ },
+ "prose#5": {
+ "findings": [],
+ "redacted": "c3280915a02ee666"
+ },
+ "prose#6": {
+ "findings": [],
+ "redacted": "01e4aaa6cbd057ef"
+ },
+ "prose#7": {
+ "findings": [],
+ "redacted": "7626a58f28010212"
+ }
+ },
+ "highEntropyLabeled": {
+ "env-dump-ai-keys#0": {
+ "findings": [
+ [
+ "anthropic",
+ 2,
+ "sha256:023913f8eeb42379",
+ "fea180102e73eb32",
+ null
+ ],
+ [
+ "openai",
+ 3,
+ "sha256:9e0fb012d7c15759",
+ "59bcae474448e3d1",
+ null
+ ],
+ [
+ "voyage",
+ 4,
+ "sha256:923669e28cb4e398",
+ "363ec23ba95a4154",
+ null
+ ]
+ ],
+ "redacted": "987276c5be395a19"
+ },
+ "env-dump-ai-keys#joined": {
+ "findings": [
+ [
+ "anthropic",
+ 2,
+ "sha256:023913f8eeb42379",
+ "fea180102e73eb32",
+ null
+ ],
+ [
+ "openai",
+ 3,
+ "sha256:9e0fb012d7c15759",
+ "59bcae474448e3d1",
+ null
+ ],
+ [
+ "voyage",
+ 4,
+ "sha256:923669e28cb4e398",
+ "363ec23ba95a4154",
+ null
+ ]
+ ],
+ "redacted": "987276c5be395a19"
+ },
+ "env-openai#0": {
+ "findings": [
+ [
+ "openai",
+ 1,
+ "sha256:9e0fb012d7c15759",
+ "15ca035573fca82b",
+ null
+ ]
+ ],
+ "redacted": "15ca035573fca82b"
+ },
+ "env-openai#joined": {
+ "findings": [
+ [
+ "openai",
+ 1,
+ "sha256:9e0fb012d7c15759",
+ "15ca035573fca82b",
+ null
+ ]
+ ],
+ "redacted": "15ca035573fca82b"
+ },
+ "env-voyage#0": {
+ "findings": [
+ [
+ "voyage",
+ 1,
+ "sha256:923669e28cb4e398",
+ "363ec23ba95a4154",
+ null
+ ]
+ ],
+ "redacted": "363ec23ba95a4154"
+ },
+ "env-voyage#joined": {
+ "findings": [
+ [
+ "voyage",
+ 1,
+ "sha256:923669e28cb4e398",
+ "363ec23ba95a4154",
+ null
+ ]
+ ],
+ "redacted": "363ec23ba95a4154"
+ },
+ "env-dump-provider-keys#0": {
+ "findings": [
+ [
+ "openrouter",
+ 1,
+ "sha256:6f3fc1fd3a97c370",
+ "0537286877599fe8",
+ "0.60.502.0"
+ ],
+ [
+ "groq",
+ 2,
+ "sha256:9bb33382932a389a",
+ "1a5eef6683de2a71",
+ "0.60.502.0"
+ ],
+ [
+ "xai",
+ 3,
+ "sha256:f519e835b3cdf05a",
+ "dccdac9669d49e59",
+ "0.60.502.0"
+ ],
+ [
+ "perplexity",
+ 4,
+ "sha256:7d6fd87c1bd4f107",
+ "b292f94ec8ed3d61",
+ "0.60.502.0"
+ ],
+ [
+ "replicate",
+ 5,
+ "sha256:6b337b60ac216986",
+ "a53a9c1f28dc4f2f",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "7cb9fe5bdafa0380"
+ },
+ "env-dump-provider-keys#joined": {
+ "findings": [
+ [
+ "openrouter",
+ 1,
+ "sha256:6f3fc1fd3a97c370",
+ "0537286877599fe8",
+ "0.60.502.0"
+ ],
+ [
+ "groq",
+ 2,
+ "sha256:9bb33382932a389a",
+ "1a5eef6683de2a71",
+ "0.60.502.0"
+ ],
+ [
+ "xai",
+ 3,
+ "sha256:f519e835b3cdf05a",
+ "dccdac9669d49e59",
+ "0.60.502.0"
+ ],
+ [
+ "perplexity",
+ 4,
+ "sha256:7d6fd87c1bd4f107",
+ "b292f94ec8ed3d61",
+ "0.60.502.0"
+ ],
+ [
+ "replicate",
+ 5,
+ "sha256:6b337b60ac216986",
+ "a53a9c1f28dc4f2f",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "7cb9fe5bdafa0380"
+ },
+ "env-groq#0": {
+ "findings": [
+ [
+ "groq",
+ 1,
+ "sha256:9bb33382932a389a",
+ "1a5eef6683de2a71",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "1a5eef6683de2a71"
+ },
+ "env-groq#joined": {
+ "findings": [
+ [
+ "groq",
+ 1,
+ "sha256:9bb33382932a389a",
+ "1a5eef6683de2a71",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "1a5eef6683de2a71"
+ },
+ "env-xai#0": {
+ "findings": [
+ [
+ "xai",
+ 1,
+ "sha256:f519e835b3cdf05a",
+ "dccdac9669d49e59",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "dccdac9669d49e59"
+ },
+ "env-xai#joined": {
+ "findings": [
+ [
+ "xai",
+ 1,
+ "sha256:f519e835b3cdf05a",
+ "dccdac9669d49e59",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "dccdac9669d49e59"
+ },
+ "env-perplexity#0": {
+ "findings": [
+ [
+ "perplexity",
+ 1,
+ "sha256:7d6fd87c1bd4f107",
+ "b292f94ec8ed3d61",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "b292f94ec8ed3d61"
+ },
+ "env-perplexity#joined": {
+ "findings": [
+ [
+ "perplexity",
+ 1,
+ "sha256:7d6fd87c1bd4f107",
+ "b292f94ec8ed3d61",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "b292f94ec8ed3d61"
+ },
+ "env-replicate#0": {
+ "findings": [
+ [
+ "replicate",
+ 1,
+ "sha256:6b337b60ac216986",
+ "a53a9c1f28dc4f2f",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "a53a9c1f28dc4f2f"
+ },
+ "env-replicate#joined": {
+ "findings": [
+ [
+ "replicate",
+ 1,
+ "sha256:6b337b60ac216986",
+ "a53a9c1f28dc4f2f",
+ "0.60.502.0"
+ ]
+ ],
+ "redacted": "a53a9c1f28dc4f2f"
+ },
+ "github-pat#0": {
+ "findings": [
+ [
+ "github_pat",
+ 1,
+ "sha256:a62fe51a20b4b1b6",
+ "4f97d23124db9835",
+ null
+ ]
+ ],
+ "redacted": "4f97d23124db9835"
+ },
+ "github-pat#joined": {
+ "findings": [
+ [
+ "github_pat",
+ 1,
+ "sha256:a62fe51a20b4b1b6",
+ "4f97d23124db9835",
+ null
+ ]
+ ],
+ "redacted": "4f97d23124db9835"
+ },
+ "env-github-token#0": {
+ "findings": [
+ [
+ "github_token",
+ 1,
+ "sha256:8834a5d5a0118aea",
+ "791d8838a3adc875",
+ null
+ ]
+ ],
+ "redacted": "791d8838a3adc875"
+ },
+ "env-github-token#joined": {
+ "findings": [
+ [
+ "github_token",
+ 1,
+ "sha256:8834a5d5a0118aea",
+ "791d8838a3adc875",
+ null
+ ]
+ ],
+ "redacted": "791d8838a3adc875"
+ },
+ "env-gitlab#0": {
+ "findings": [
+ [
+ "gitlab_pat",
+ 1,
+ "sha256:afa671dd897470c0",
+ "312620bbae01d289",
+ null
+ ]
+ ],
+ "redacted": "312620bbae01d289"
+ },
+ "env-gitlab#joined": {
+ "findings": [
+ [
+ "gitlab_pat",
+ 1,
+ "sha256:afa671dd897470c0",
+ "312620bbae01d289",
+ null
+ ]
+ ],
+ "redacted": "312620bbae01d289"
+ },
+ "chat-tokens#0": {
+ "findings": [
+ [
+ "slack",
+ 1,
+ "sha256:d7d06bcaa307a158",
+ "33cfe69f0492d2ea",
+ null
+ ],
+ [
+ "slack",
+ 1,
+ "sha256:2f7a9a64dc16288c",
+ "33cfe69f0492d2ea",
+ null
+ ]
+ ],
+ "redacted": "33cfe69f0492d2ea"
+ },
+ "chat-tokens#joined": {
+ "findings": [
+ [
+ "slack",
+ 1,
+ "sha256:d7d06bcaa307a158",
+ "33cfe69f0492d2ea",
+ null
+ ],
+ [
+ "slack",
+ 1,
+ "sha256:2f7a9a64dc16288c",
+ "33cfe69f0492d2ea",
+ null
+ ]
+ ],
+ "redacted": "33cfe69f0492d2ea"
+ },
+ "cloud-aws#0": {
+ "findings": [
+ [
+ "aws_access_key",
+ 2,
+ "sha256:a3d13cdfbf13028e",
+ "0b6f0bb71e505121",
+ null
+ ],
+ [
+ "high_entropy_assignment",
+ 3,
+ "sha256:e2aecdfb48e5cf9a",
+ "e02816c5504806ed",
+ null
+ ]
+ ],
+ "redacted": "06f6a80f1900e699"
+ },
+ "cloud-aws#joined": {
+ "findings": [
+ [
+ "aws_access_key",
+ 2,
+ "sha256:a3d13cdfbf13028e",
+ "0b6f0bb71e505121",
+ null
+ ],
+ [
+ "high_entropy_assignment",
+ 3,
+ "sha256:e2aecdfb48e5cf9a",
+ "e02816c5504806ed",
+ null
+ ]
+ ],
+ "redacted": "06f6a80f1900e699"
+ },
+ "cloud-google#0": {
+ "findings": [
+ [
+ "google_api_key",
+ 1,
+ "sha256:005d435bb16e204f",
+ "bb51f041f49b82b6",
+ null
+ ]
+ ],
+ "redacted": "bb51f041f49b82b6"
+ },
+ "cloud-google#joined": {
+ "findings": [
+ [
+ "google_api_key",
+ 1,
+ "sha256:005d435bb16e204f",
+ "bb51f041f49b82b6",
+ null
+ ]
+ ],
+ "redacted": "bb51f041f49b82b6"
+ },
+ "stripe-keys#0": {
+ "findings": [
+ [
+ "stripe",
+ 1,
+ "sha256:abeef5774c6493e0",
+ "803a594ced4f77a8",
+ null
+ ],
+ [
+ "stripe",
+ 2,
+ "sha256:ae1bcf651f22d1d8",
+ "da116bb48f7368dc",
+ null
+ ]
+ ],
+ "redacted": "5f13fadbc182c39d"
+ },
+ "stripe-keys#joined": {
+ "findings": [
+ [
+ "stripe",
+ 1,
+ "sha256:abeef5774c6493e0",
+ "803a594ced4f77a8",
+ null
+ ],
+ [
+ "stripe",
+ 2,
+ "sha256:ae1bcf651f22d1d8",
+ "da116bb48f7368dc",
+ null
+ ]
+ ],
+ "redacted": "5f13fadbc182c39d"
+ },
+ "sendgrid#0": {
+ "findings": [
+ [
+ "sendgrid",
+ 1,
+ "sha256:48c847e79d74f12c",
+ "f068d6b4b67b580a",
+ null
+ ]
+ ],
+ "redacted": "f068d6b4b67b580a"
+ },
+ "sendgrid#joined": {
+ "findings": [
+ [
+ "sendgrid",
+ 1,
+ "sha256:48c847e79d74f12c",
+ "f068d6b4b67b580a",
+ null
+ ]
+ ],
+ "redacted": "f068d6b4b67b580a"
+ },
+ "twilio#0": {
+ "findings": [
+ [
+ "twilio",
+ 1,
+ "sha256:b363ade84d56c43b",
+ "1e5763c415956bac",
+ null
+ ]
+ ],
+ "redacted": "1e5763c415956bac"
+ },
+ "twilio#joined": {
+ "findings": [
+ [
+ "twilio",
+ 1,
+ "sha256:b363ade84d56c43b",
+ "1e5763c415956bac",
+ null
+ ]
+ ],
+ "redacted": "1e5763c415956bac"
+ },
+ "supabase#0": {
+ "findings": [
+ [
+ "supabase_key",
+ 1,
+ "sha256:df9f2fed0b280eef",
+ "a45a626af1e5c3c5",
+ null
+ ],
+ [
+ "supabase_key",
+ 2,
+ "sha256:8246ef07a213a4d9",
+ "24031044052fb00b",
+ null
+ ]
+ ],
+ "redacted": "a75c7beb2122696c"
+ },
+ "supabase#joined": {
+ "findings": [
+ [
+ "supabase_key",
+ 1,
+ "sha256:df9f2fed0b280eef",
+ "a45a626af1e5c3c5",
+ null
+ ],
+ [
+ "supabase_key",
+ 2,
+ "sha256:8246ef07a213a4d9",
+ "24031044052fb00b",
+ null
+ ]
+ ],
+ "redacted": "a75c7beb2122696c"
+ },
+ "npmrc#0": {
+ "findings": [
+ [
+ "npm_token",
+ 1,
+ "sha256:7b370ae3d08eef8b",
+ "b1dc9a6c46b49690",
+ null
+ ]
+ ],
+ "redacted": "b1dc9a6c46b49690"
+ },
+ "npmrc#joined": {
+ "findings": [
+ [
+ "npm_token",
+ 1,
+ "sha256:7b370ae3d08eef8b",
+ "b1dc9a6c46b49690",
+ null
+ ]
+ ],
+ "redacted": "b1dc9a6c46b49690"
+ },
+ "huggingface#0": {
+ "findings": [
+ [
+ "huggingface",
+ 1,
+ "sha256:24d754fc36ced0a6",
+ "09634a2a8c712cb7",
+ null
+ ]
+ ],
+ "redacted": "09634a2a8c712cb7"
+ },
+ "huggingface#joined": {
+ "findings": [
+ [
+ "huggingface",
+ 1,
+ "sha256:24d754fc36ced0a6",
+ "09634a2a8c712cb7",
+ null
+ ]
+ ],
+ "redacted": "09634a2a8c712cb7"
+ },
+ "digitalocean#0": {
+ "findings": [
+ [
+ "digitalocean",
+ 1,
+ "sha256:9e4a4330bc71d7ac",
+ "ffbd7ee5a6e6f46e",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "ffbd7ee5a6e6f46e"
+ },
+ "digitalocean#joined": {
+ "findings": [
+ [
+ "digitalocean",
+ 1,
+ "sha256:9e4a4330bc71d7ac",
+ "ffbd7ee5a6e6f46e",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "ffbd7ee5a6e6f46e"
+ },
+ "gbrain-token#0": {
+ "findings": [
+ [
+ "gbrain_token",
+ 1,
+ "sha256:b6c4732b5b567235",
+ "27841e289ad29eb0",
+ null
+ ]
+ ],
+ "redacted": "27841e289ad29eb0"
+ },
+ "gbrain-token#joined": {
+ "findings": [
+ [
+ "gbrain_token",
+ 1,
+ "sha256:b6c4732b5b567235",
+ "27841e289ad29eb0",
+ null
+ ]
+ ],
+ "redacted": "27841e289ad29eb0"
+ },
+ "jwt#0": {
+ "findings": [
+ [
+ "jwt",
+ 1,
+ "sha256:4eb3833f048793cf",
+ "496eaa6fc37ab873",
+ null
+ ]
+ ],
+ "redacted": "496eaa6fc37ab873"
+ },
+ "jwt#joined": {
+ "findings": [
+ [
+ "jwt",
+ 1,
+ "sha256:4eb3833f048793cf",
+ "496eaa6fc37ab873",
+ null
+ ]
+ ],
+ "redacted": "496eaa6fc37ab873"
+ },
+ "curl-bearer#0": {
+ "findings": [
+ [
+ "bearer",
+ 1,
+ "sha256:ce77318a533b584c",
+ "6152f12a5d4241b2",
+ null
+ ]
+ ],
+ "redacted": "6152f12a5d4241b2"
+ },
+ "curl-bearer#joined": {
+ "findings": [
+ [
+ "bearer",
+ 1,
+ "sha256:ce77318a533b584c",
+ "6152f12a5d4241b2",
+ null
+ ]
+ ],
+ "redacted": "6152f12a5d4241b2"
+ },
+ "database-url#0": {
+ "findings": [
+ [
+ "db_url_credentials",
+ 1,
+ "sha256:c99d8e7f261fce8c",
+ "742691068b7f87ca",
+ null
+ ]
+ ],
+ "redacted": "742691068b7f87ca"
+ },
+ "database-url#joined": {
+ "findings": [
+ [
+ "db_url_credentials",
+ 1,
+ "sha256:c99d8e7f261fce8c",
+ "742691068b7f87ca",
+ null
+ ]
+ ],
+ "redacted": "742691068b7f87ca"
+ },
+ "git-url-credentials#0": {
+ "findings": [
+ [
+ "url_credentials",
+ 1,
+ "sha256:e71f032d4f3308ec",
+ "6bee57c8d7b67ed9",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "6bee57c8d7b67ed9"
+ },
+ "git-url-credentials#joined": {
+ "findings": [
+ [
+ "url_credentials",
+ 1,
+ "sha256:e71f032d4f3308ec",
+ "6bee57c8d7b67ed9",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "6bee57c8d7b67ed9"
+ },
+ "curl-basic#0": {
+ "findings": [
+ [
+ "basic_auth",
+ 1,
+ "sha256:773fe1da02bbcf94",
+ "52c43f87174d4c3e",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "52c43f87174d4c3e"
+ },
+ "curl-basic#joined": {
+ "findings": [
+ [
+ "basic_auth",
+ 1,
+ "sha256:773fe1da02bbcf94",
+ "52c43f87174d4c3e",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "52c43f87174d4c3e"
+ },
+ "pem-block#0": {
+ "findings": [
+ [
+ "private_key_pem",
+ 2,
+ "sha256:48f492fad8b2c504",
+ "96dffd8709b784ec",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "a699ad1bd3d6ea5a"
+ },
+ "pem-block#joined": {
+ "findings": [
+ [
+ "private_key_pem",
+ 2,
+ "sha256:48f492fad8b2c504",
+ "96dffd8709b784ec",
+ "0.60.31.0"
+ ]
+ ],
+ "redacted": "a699ad1bd3d6ea5a"
+ },
+ "entropy-assignment#0": {
+ "findings": [
+ [
+ "high_entropy_assignment",
+ 1,
+ "sha256:e2aecdfb48e5cf9a",
+ "5378a25e9f4cd764",
+ null
+ ]
+ ],
+ "redacted": "5378a25e9f4cd764"
+ },
+ "entropy-assignment#joined": {
+ "findings": [
+ [
+ "high_entropy_assignment",
+ 1,
+ "sha256:e2aecdfb48e5cf9a",
+ "5378a25e9f4cd764",
+ null
+ ]
+ ],
+ "redacted": "5378a25e9f4cd764"
+ },
+ "json-password#0": {
+ "findings": [
+ [
+ "labeled_credential",
+ 1,
+ "sha256:ffb61cb3778b0ddf",
+ "04199d9df56f337e",
+ null
+ ]
+ ],
+ "redacted": "04199d9df56f337e"
+ },
+ "json-password#joined": {
+ "findings": [
+ [
+ "labeled_credential",
+ 1,
+ "sha256:ffb61cb3778b0ddf",
+ "04199d9df56f337e",
+ null
+ ]
+ ],
+ "redacted": "04199d9df56f337e"
+ },
+ "netrc-line#0": {
+ "findings": [],
+ "redacted": "26b379bcf151a445"
+ },
+ "netrc-line#joined": {
+ "findings": [],
+ "redacted": "26b379bcf151a445"
+ },
+ "login-pair#0": {
+ "findings": [
+ [
+ "labeled_credential",
+ 1,
+ "sha256:8cb8a16451d5472d",
+ "1364dc10c77ad192",
+ null
+ ]
+ ],
+ "redacted": "1364dc10c77ad192"
+ },
+ "login-pair#joined": {
+ "findings": [
+ [
+ "labeled_credential",
+ 1,
+ "sha256:8cb8a16451d5472d",
+ "1364dc10c77ad192",
+ null
+ ]
+ ],
+ "redacted": "1364dc10c77ad192"
+ },
+ "cli-password#0": {
+ "findings": [
+ [
+ "labeled_credential",
+ 1,
+ "sha256:c82f41fe9a8478ff",
+ "a9e6055c692f978d",
+ null
+ ]
+ ],
+ "redacted": "a9e6055c692f978d"
+ },
+ "cli-password#joined": {
+ "findings": [
+ [
+ "labeled_credential",
+ 1,
+ "sha256:c82f41fe9a8478ff",
+ "a9e6055c692f978d",
+ null
+ ]
+ ],
+ "redacted": "a9e6055c692f978d"
+ },
+ "cookie-curl-header#0": {
+ "findings": [],
+ "redacted": "3634e83f4feb027c"
+ },
+ "cookie-curl-header#joined": {
+ "findings": [],
+ "redacted": "3634e83f4feb027c"
+ },
+ "cookie-devtools#0": {
+ "findings": [],
+ "redacted": "5c9d1f29f3b1cf85"
+ },
+ "cookie-devtools#joined": {
+ "findings": [],
+ "redacted": "5c9d1f29f3b1cf85"
+ },
+ "set-cookie#0": {
+ "findings": [],
+ "redacted": "b62d689c3b146e3d"
+ },
+ "set-cookie#joined": {
+ "findings": [],
+ "redacted": "b62d689c3b146e3d"
+ },
+ "cookie-curl-b#0": {
+ "findings": [],
+ "redacted": "daf8440250be80b2"
+ },
+ "cookie-curl-b#joined": {
+ "findings": [],
+ "redacted": "daf8440250be80b2"
+ },
+ "cookie-fetch-json#0": {
+ "findings": [],
+ "redacted": "f007539fa76c3f9e"
+ },
+ "cookie-fetch-json#joined": {
+ "findings": [],
+ "redacted": "f007539fa76c3f9e"
+ },
+ "split-key-messages#0": {
+ "findings": [],
+ "redacted": "6162dbe5ff2e98fd"
+ },
+ "split-key-messages#1": {
+ "findings": [],
+ "redacted": "8984688825f36c25"
+ },
+ "split-key-messages#joined": {
+ "findings": [],
+ "redacted": "8f70201aea5ce999"
+ },
+ "split-password-messages#0": {
+ "findings": [],
+ "redacted": "c304787445ce7cab"
+ },
+ "split-password-messages#1": {
+ "findings": [],
+ "redacted": "d2b3f565dc3a4dc8"
+ },
+ "split-password-messages#joined": {
+ "findings": [
+ [
+ "labeled_credential",
+ 2,
+ "sha256:d2b3f565dc3a4dc8",
+ "3865e05eba46b7bb",
+ null
+ ]
+ ],
+ "redacted": "a8e7eec6823d7cf0"
+ },
+ "split-pair-messages#0": {
+ "findings": [],
+ "redacted": "ce35f81b6ef6d5f1"
+ },
+ "split-pair-messages#1": {
+ "findings": [],
+ "redacted": "315959dd542ff5b3"
+ },
+ "split-pair-messages#joined": {
+ "findings": [
+ [
+ "labeled_credential",
+ 2,
+ "sha256:139ec225a736f550",
+ "64be9e14023db3a3",
+ null
+ ]
+ ],
+ "redacted": "91bf0b2a6b1c7832"
+ },
+ "split-token-lines#0": {
+ "findings": [],
+ "redacted": "7b0c6dfab13239ec"
+ },
+ "split-token-lines#joined": {
+ "findings": [],
+ "redacted": "7b0c6dfab13239ec"
+ },
+ "prose#0": {
+ "findings": [],
+ "redacted": "b70707f7c770dd8a"
+ },
+ "prose#1": {
+ "findings": [],
+ "redacted": "93d025a6d32e2f2b"
+ },
+ "prose#2": {
+ "findings": [],
+ "redacted": "92f10d223e427fb0"
+ },
+ "prose#3": {
+ "findings": [],
+ "redacted": "4979bc840e9ada2a"
+ },
+ "prose#4": {
+ "findings": [],
+ "redacted": "0a0f4a0c23870ccd"
+ },
+ "prose#5": {
+ "findings": [],
+ "redacted": "c3280915a02ee666"
+ },
+ "prose#6": {
+ "findings": [],
+ "redacted": "01e4aaa6cbd057ef"
+ },
+ "prose#7": {
+ "findings": [],
+ "redacted": "7626a58f28010212"
+ }
+ }
+}
diff --git a/test/fixtures/transcripts/synthetic-credentials.ts b/test/fixtures/transcripts/synthetic-credentials.ts
new file mode 100644
index 0000000000..2dd6c5f271
--- /dev/null
+++ b/test/fixtures/transcripts/synthetic-credentials.ts
@@ -0,0 +1,200 @@
+/**
+ * Synthetic credential corpus for the transcript lane (GST-2768 PR 1).
+ *
+ * Every value here is fake: obviously synthetic text (SYNTHETIC, Synth...,
+ * acme-example.test hosts) padded to the shape a detector reads. Values are
+ * assembled at runtime from parts so no committed line carries a key-shaped
+ * literal (gitleaks, CEO-10). The texts mimic what lands in a pasted agent
+ * session: env dumps, curl commands with headers, JSON config blobs, .netrc
+ * lines, database URLs, bearer and basic auth, JWTs, PEM blocks, cloud keys,
+ * chat tokens, cookie headers, and a label whose value arrives on the next
+ * line or in the next message.
+ *
+ * `kind` is the rule expected to claim the entry's secrets in the transcript
+ * lane; `secrets` are the exact values that must not survive redaction. A
+ * `messages` array longer than one is a label in one message and its value in
+ * the next.
+ */
+const j = (...parts: string[]): string => parts.join('');
+/** A SYNTHETIC head padded with 0 to exactly n characters (alphanumeric). */
+const synth = (n: number, head = 'SYNTHETICfake'): string => head.padEnd(n, '0').slice(0, n);
+const HEX64 = '0123456789abcdef'.repeat(4);
+
+export interface CredentialCorpusEntry {
+ id: string;
+ /** The rule that claims the secrets in the transcript lane. */
+ kind: string;
+ /** Where the text typically comes from in a pasted session. */
+ shape: string;
+ /** One message, or a label in one message and its value in the next. */
+ messages: string[];
+ secrets: string[];
+}
+
+const v = {
+ anthropic: j('sk-', 'ant-', 'api03-', synth(28)),
+ openai: j('sk-', 'proj-', synth(32)),
+ voyage: j('pa', '-', synth(28)),
+ githubPat: j('github', '_pat_', synth(30)),
+ githubToken: j('gh', 'p_', synth(36)),
+ gitlab: j('gl', 'pat-', synth(24)),
+ slackBot: j('xox', 'b-', '000000000000-', synth(24)),
+ slackUser: j('xox', 'p-', '000000000000-', synth(24, 'SYNTHETICuser')),
+ aws: j('AK', 'IA', 'SYNTHETIC0000001'),
+ google: j('AI', 'za', synth(35)),
+ stripe: j('sk', '_live_', synth(28)),
+ stripeHook: j('wh', 'sec_', synth(28)),
+ sendgrid: j('SG', '.', synth(22), '.', synth(43, 'SYNTHETICpart')),
+ twilio: j('A', 'C', HEX64.slice(0, 32)),
+ supabase: j('sb', '_secret_', synth(28)),
+ supabaseMgmt: j('sb', 'p_', HEX64.slice(0, 40)),
+ npm: j('np', 'm_', synth(36)),
+ huggingface: j('h', 'f_', synth(34)),
+ digitalocean: j('do', 'p_v1_', HEX64),
+ openrouter: j('sk-', 'or-', 'v1-', HEX64),
+ groq: j('gs', 'k_', synth(52)),
+ xai: j('xa', 'i-', synth(80)),
+ perplexity: j('pp', 'lx-', synth(48)),
+ replicate: j('r', '8_', synth(37)),
+ gbrain: j('gbrain', '_at_', HEX64),
+ jwt: j('ey', 'JhbGciOiJIUzI1NiJ9', '.', 'ey', 'JzdWIiOiJzeW50aGV0aWMifQ', '.', 'SYNTHETICsignature0000'),
+ bearer: j('SYNTHETIC', 'opaqueBearer0000fake'),
+ dbPass: j('Synth', 'PgPass01'),
+ urlPass: j('Synth', 'UrlPass9'),
+ basic: Buffer.from(j('alice-example', ':', 'Synth', 'BasicPass01')).toString('base64'),
+ pemBody: [
+ Buffer.from('SYNTHETIC-PRIVATE-KEY-BODY-LINE-ONE-NOT-A-REAL-KEY-000000').toString('base64'),
+ Buffer.from('SYNTHETIC-PRIVATE-KEY-BODY-LINE-TWO-NOT-A-REAL-KEY-000000').toString('base64'),
+ ],
+ entropy: j('Synth3tic', 'FakeValue0Not4Real9xQzW'),
+ jsonPassword: j('Synth', '-pw-77'),
+ netrcPassword: j('Synth', '3ticNetrc!'),
+ pairPassword: j('Synth', '-pw-3!'),
+ cliPassword: j('Synth', '-cli-pw7'),
+ cookieSid: j('SYNTH', 'sid0001fake'),
+ cookieDevtools: j('SYNTH', 'session0001fake'),
+ cookieSet: j('SYNTH', 'setcookie0002'),
+ cookieCurlB: j('SYNTH', 'curlb0003'),
+ cookieJson: j('SYNTH', 'json0004value'),
+ splitKey: j('Synth3tic', 'ApiKeyValue0042'),
+ splitPassword: j('Synth', '-pw-split-9'),
+ splitLineToken: j('Synth3tic', 'Tok3nValue0099'),
+ splitPair: j('Synth', '-pair-5!'),
+};
+
+const fence = '-'.repeat(5);
+const pemLabel = ['PRIVATE', 'KEY'].join(' ');
+
+export const SYNTHETIC_CREDENTIAL_CORPUS: readonly CredentialCorpusEntry[] = [
+ {
+ id: 'env-dump-ai-keys', kind: 'anthropic', shape: 'env dump',
+ messages: [[
+ '$ env | grep KEY',
+ `ANTHROPIC_API_KEY=${v.anthropic}`,
+ `OPENAI_API_KEY=${v.openai}`,
+ `VOYAGE_API_KEY=${v.voyage}`,
+ ].join('\n')],
+ secrets: [v.anthropic, v.openai, v.voyage],
+ },
+ { id: 'env-openai', kind: 'openai', shape: 'env dump', messages: [`export OPENAI_API_KEY="${v.openai}"`], secrets: [v.openai] },
+ { id: 'env-voyage', kind: 'voyage', shape: 'env dump', messages: [`VOYAGE_API_KEY=${v.voyage}`], secrets: [v.voyage] },
+ {
+ id: 'env-dump-provider-keys', kind: 'openrouter', shape: 'env dump',
+ messages: [[
+ `OPENROUTER_API_KEY=${v.openrouter}`,
+ `GROQ_API_KEY=${v.groq}`,
+ `XAI_API_KEY=${v.xai}`,
+ `PERPLEXITY_API_KEY=${v.perplexity}`,
+ `REPLICATE_API_TOKEN=${v.replicate}`,
+ ].join('\n')],
+ secrets: [v.openrouter, v.groq, v.xai, v.perplexity, v.replicate],
+ },
+ { id: 'env-groq', kind: 'groq', shape: 'env dump', messages: [`GROQ_API_KEY=${v.groq}`], secrets: [v.groq] },
+ { id: 'env-xai', kind: 'xai', shape: 'env dump', messages: [`XAI_API_KEY=${v.xai}`], secrets: [v.xai] },
+ { id: 'env-perplexity', kind: 'perplexity', shape: 'env dump', messages: [`PERPLEXITY_API_KEY=${v.perplexity}`], secrets: [v.perplexity] },
+ { id: 'env-replicate', kind: 'replicate', shape: 'env dump', messages: [`REPLICATE_API_TOKEN=${v.replicate}`], secrets: [v.replicate] },
+ { id: 'github-pat', kind: 'github_pat', shape: 'tool output', messages: [`gh auth status shows token ${v.githubPat}`], secrets: [v.githubPat] },
+ { id: 'env-github-token', kind: 'github_token', shape: 'env dump', messages: [`GITHUB_TOKEN=${v.githubToken} gh pr list`], secrets: [v.githubToken] },
+ { id: 'env-gitlab', kind: 'gitlab_pat', shape: 'env dump', messages: [`GITLAB_TOKEN=${v.gitlab}`], secrets: [v.gitlab] },
+ {
+ id: 'chat-tokens', kind: 'slack', shape: 'JSON config blob',
+ messages: [`{"slack": {"bot_token": "${v.slackBot}", "user_token": "${v.slackUser}"}}`],
+ secrets: [v.slackBot, v.slackUser],
+ },
+ {
+ id: 'cloud-aws', kind: 'aws_access_key', shape: 'aws credentials file',
+ messages: [['[default]', `aws_access_key_id = ${v.aws}`, `aws_secret_access_key = ${v.entropy}`].join('\n')],
+ secrets: [v.aws, v.entropy],
+ },
+ { id: 'cloud-google', kind: 'google_api_key', shape: 'curl command', messages: [`curl "https://maps.acme-example.test/api?key=${v.google}"`], secrets: [v.google] },
+ {
+ id: 'stripe-keys', kind: 'stripe', shape: 'env dump',
+ messages: [[`STRIPE_SECRET_KEY=${v.stripe}`, `STRIPE_WEBHOOK_SECRET=${v.stripeHook}`].join('\n')],
+ secrets: [v.stripe, v.stripeHook],
+ },
+ { id: 'sendgrid', kind: 'sendgrid', shape: 'JSON config blob', messages: [`{"mail": {"provider": "sendgrid", "key": "${v.sendgrid}"}}`], secrets: [v.sendgrid] },
+ { id: 'twilio', kind: 'twilio', shape: 'tool output', messages: [`twilio account ${v.twilio} configured`], secrets: [v.twilio] },
+ {
+ id: 'supabase', kind: 'supabase_key', shape: 'env dump',
+ messages: [[`SUPABASE_SECRET=${v.supabase}`, `SUPABASE_ACCESS=${v.supabaseMgmt}`].join('\n')],
+ secrets: [v.supabase, v.supabaseMgmt],
+ },
+ { id: 'npmrc', kind: 'npm_token', shape: '.npmrc line', messages: [`//registry.npmjs.org/:_authToken=${v.npm}`], secrets: [v.npm] },
+ { id: 'huggingface', kind: 'huggingface', shape: 'shell command', messages: [`huggingface-cli login --token ${v.huggingface}`], secrets: [v.huggingface] },
+ { id: 'digitalocean', kind: 'digitalocean', shape: 'env dump', messages: [`DIGITALOCEAN_ACCESS_TOKEN=${v.digitalocean}`], secrets: [v.digitalocean] },
+ { id: 'gbrain-token', kind: 'gbrain_token', shape: 'MCP config', messages: [`{"mcpServers": {"gbrain": {"headers": {"X-Token": "${v.gbrain}"}}}}`], secrets: [v.gbrain] },
+ { id: 'jwt', kind: 'jwt', shape: 'tool output', messages: [`decoded session: ${v.jwt} (expires in 1h)`], secrets: [v.jwt] },
+ {
+ id: 'curl-bearer', kind: 'bearer', shape: 'curl command with headers',
+ messages: [`curl -s -H "Authorization: Bearer ${v.bearer}" -H 'Accept: application/json' https://api.acme-example.test/v1/me`],
+ secrets: [v.bearer],
+ },
+ { id: 'database-url', kind: 'db_url_credentials', shape: 'database URL', messages: [`DATABASE_URL=postgres://app_user:${v.dbPass}@db.acme-example.test:5432/app`], secrets: [v.dbPass] },
+ { id: 'git-url-credentials', kind: 'url_credentials', shape: 'tool output', messages: [`git clone https://alice-example:${v.urlPass}@git.acme-example.test/source-a.git`], secrets: [v.urlPass] },
+ { id: 'curl-basic', kind: 'basic_auth', shape: 'curl command with headers', messages: [`curl -H "Authorization: Basic ${v.basic}" https://api.acme-example.test/health`], secrets: [v.basic] },
+ {
+ id: 'pem-block', kind: 'private_key_pem', shape: 'PEM block',
+ messages: [['cat ~/.ssh/deploy_key', `${fence}BEGIN ${pemLabel}${fence}`, ...v.pemBody, `${fence}END ${pemLabel}${fence}`].join('\n')],
+ secrets: v.pemBody,
+ },
+ { id: 'entropy-assignment', kind: 'high_entropy_assignment', shape: 'env dump', messages: [`AWS_SECRET_ACCESS_KEY=${v.entropy}`], secrets: [v.entropy] },
+ { id: 'json-password', kind: 'labeled_credential', shape: 'JSON config blob', messages: [`{"db": {"user": "app_user", "password": "${v.jsonPassword}"}}`], secrets: [v.jsonPassword] },
+ { id: 'netrc-line', kind: 'labeled_credential', shape: '.netrc line', messages: [`machine api.acme-example.test login alice-example password ${v.netrcPassword}`], secrets: [v.netrcPassword] },
+ { id: 'login-pair', kind: 'labeled_credential', shape: 'chat prose', messages: [`login alice-example / ${v.pairPassword}`], secrets: [v.pairPassword] },
+ { id: 'cli-password', kind: 'labeled_credential', shape: 'shell command', messages: [`mysql -u app_user --password ${v.cliPassword} app`], secrets: [v.cliPassword] },
+ // Cookie headers (transcript-lane cookie_header rule).
+ {
+ id: 'cookie-curl-header', kind: 'cookie_header', shape: 'curl command with headers',
+ messages: [`curl -H 'Cookie: sid=${v.cookieSid}; theme=dark' https://app.acme-example.test/account`],
+ secrets: [v.cookieSid],
+ },
+ {
+ id: 'cookie-devtools', kind: 'cookie_header', shape: 'browser devtools copy',
+ messages: [['GET /account HTTP/1.1', 'Host: app.acme-example.test', `cookie: _ga=GA1.2.100.200; sessionid=${v.cookieDevtools}`, 'accept: text/html'].join('\n')],
+ secrets: [v.cookieDevtools],
+ },
+ {
+ id: 'set-cookie', kind: 'cookie_header', shape: 'HTTP response headers',
+ messages: [['HTTP/1.1 302 Found', `Set-Cookie: sessionid=${v.cookieSet}; Path=/; HttpOnly; Secure; SameSite=Lax`, 'Location: /home'].join('\n')],
+ secrets: [v.cookieSet],
+ },
+ { id: 'cookie-curl-b', kind: 'cookie_header', shape: 'curl command', messages: [`curl -b 'sid=${v.cookieCurlB}' https://app.acme-example.test/`], secrets: [v.cookieCurlB] },
+ { id: 'cookie-fetch-json', kind: 'cookie_header', shape: 'devtools copy as fetch', messages: [`fetch("https://app.acme-example.test/", {"headers": {"cookie": "sid=${v.cookieJson}"}});`], secrets: [v.cookieJson] },
+ // A label whose value arrives on the next line or in the next message.
+ { id: 'split-key-messages', kind: 'labeled_credential', shape: 'label and value in two messages', messages: ['here is my API key:', v.splitKey], secrets: [v.splitKey] },
+ { id: 'split-password-messages', kind: 'labeled_credential', shape: 'label and value in two messages', messages: ['password:', v.splitPassword], secrets: [v.splitPassword] },
+ { id: 'split-pair-messages', kind: 'labeled_credential', shape: 'label and value in two messages', messages: ['login: alice-example /', v.splitPair], secrets: [v.splitPair] },
+ { id: 'split-token-lines', kind: 'labeled_credential', shape: 'label and value on two lines', messages: [`ok, the access token:\n${v.splitLineToken}`], secrets: [v.splitLineToken] },
+];
+
+/** Prose that mentions cookies and must come through the cookie rule unchanged. */
+export const COOKIE_PROSE_NEGATIVES: readonly string[] = [
+ 'I cleared my cookies: nothing changed.',
+ 'Cookie: chocolate chip, oatmeal raisin.',
+ 'The Set-Cookie header sets Path=/ and HttpOnly by default.',
+ 'cookie banners: accept=all is the default on most sites',
+ 'Check the Cookie: header in devtools if login fails.',
+ 'Cookie: <your session cookie here>',
+ 'Cookie: sid=...; theme=...',
+ 'set it as Cookie: sid=$SID; theme=dark in the request',
+];
diff --git a/test/secret-scan-push-gate-unchanged.test.ts b/test/secret-scan-push-gate-unchanged.test.ts
new file mode 100644
index 0000000000..b81c3b3fc6
--- /dev/null
+++ b/test/secret-scan-push-gate-unchanged.test.ts
@@ -0,0 +1,79 @@
+/**
+ * GST-2768 PR 1: the cookie_header rule, the .netrc password form and the
+ * cross-line / cross-message label join are transcript-lane opt-ins. Every
+ * other lane (the sources-push gate and bootstrap verify with default
+ * options, the compiled-context scan, the highEntropy-only redactors, the
+ * labeled-credential callers outside transcripts) must give byte-identical
+ * results on the synthetic credential corpus before and after.
+ *
+ * The golden was generated on master before the change
+ * (GBRAIN_TEST_UPDATE_GOLDENS=1). It stores only rule names, line numbers,
+ * fingerprints and sha256 digests of previews and redacted output, never text.
+ */
+import { describe, expect, test } from 'bun:test';
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import * as scan from '../src/core/secret-scan.ts';
+import { COOKIE_PROSE_NEGATIVES, SYNTHETIC_CREDENTIAL_CORPUS } from './fixtures/transcripts/synthetic-credentials.ts';
+
+const GOLDEN = join(import.meta.dir, 'fixtures/transcripts/synthetic-credentials.shared-scanner.golden.json');
+const sha = (s: string): string => createHash('sha256').update(s).digest('hex').slice(0, 16);
+
+const OPTION_SETS: Record<string, scan.ScanOpts> = {
+ default: {},
+ highEntropy: { highEntropy: true },
+ labeledCredentials: { labeledCredentials: true },
+ highEntropyLabeled: { highEntropy: true, labeledCredentials: true },
+};
+
+function texts(): Array<[string, string]> {
+ const out: Array<[string, string]> = [];
+ for (const e of SYNTHETIC_CREDENTIAL_CORPUS) {
+ e.messages.forEach((m, i) => out.push([`${e.id}#${i}`, m]));
+ out.push([`${e.id}#joined`, e.messages.join('\n')]);
+ }
+ COOKIE_PROSE_NEGATIVES.forEach((t, i) => out.push([`prose#${i}`, t]));
+ return out;
+}
+
+function snapshot(): Record<string, Record<string, unknown>> {
+ const out: Record<string, Record<string, unknown>> = {};
+ for (const [name, opts] of Object.entries(OPTION_SETS)) {
+ const perText: Record<string, unknown> = {};
+ for (const [id, text] of texts()) {
+ const plan = scan.planRedaction(text, opts);
+ perText[id] = {
+ findings: scan.scanText(text, opts).map((f) => [f.pattern, f.line, f.fingerprint, sha(f.redactedPreview), f.since ?? null]),
+ redacted: sha(scan.applyRedaction(plan)),
+ };
+ }
+ out[name] = perText;
+ }
+ return out;
+}
+
+describe('shared scanner unchanged outside the transcript lane', () => {
+ test('every non-transcript option set matches the pre-change golden byte for byte', () => {
+ const now = snapshot();
+ if (process.env.GBRAIN_TEST_UPDATE_GOLDENS === '1' || !existsSync(GOLDEN)) writeFileSync(GOLDEN, JSON.stringify(now, null, 1) + '\n');
+ expect(now).toEqual(JSON.parse(readFileSync(GOLDEN, 'utf8')));
+ });
+
+ test('the transcript-lane options are the shared defaults plus the transcript rules', () => {
+ expect(scan.TRANSCRIPT_LANE_SCAN_OPTS).toEqual({ highEntropy: true, labeledCredentials: true, transcriptRules: true });
+ });
+
+ test('the new rules fire only with the transcript-lane options', () => {
+ const cookie = SYNTHETIC_CREDENTIAL_CORPUS.filter((e) => e.kind === 'cookie_header');
+ expect(cookie.length).toBeGreaterThan(0);
+ for (const e of cookie) {
+ const text = e.messages.join('\n');
+ for (const opts of Object.values(OPTION_SETS)) expect(scan.scanText(text, opts).some((f) => f.pattern === 'cookie_header')).toBe(false);
+ expect(scan.scanText(text, scan.TRANSCRIPT_LANE_SCAN_OPTS).some((f) => f.pattern === 'cookie_header')).toBe(true);
+ }
+ const netrc = SYNTHETIC_CREDENTIAL_CORPUS.find((e) => e.id === 'netrc-line')!;
+ for (const opts of Object.values(OPTION_SETS)) expect(scan.redactFindings(netrc.messages[0]!, opts).text).toContain(netrc.secrets[0]!);
+ expect(scan.redactFindings(netrc.messages[0]!, scan.TRANSCRIPT_LANE_SCAN_OPTS).text).not.toContain(netrc.secrets[0]!);
+ });
+});
diff --git a/test/transcripts-secret-cookie-header.test.ts b/test/transcripts-secret-cookie-header.test.ts
new file mode 100644
index 0000000000..9f5b27efbb
--- /dev/null
+++ b/test/transcripts-secret-cookie-header.test.ts
@@ -0,0 +1,130 @@
+/**
+ * GST-2768 PR 1: Cookie and Set-Cookie header values in a pasted session
+ * (curl -H / -b / --cookie arguments, raw HTTP headers, a devtools copy, a
+ * copy-as-fetch JSON blob) reached the conversation page verbatim: no
+ * detector reads a cookie value that is not a known token shape. The
+ * transcript lane now claims each cookie value (cookie_header) and keeps the
+ * cookie names, Set-Cookie attributes and ordinary prose about cookies.
+ * Values are synthetic and built from parts (CEO-10).
+ */
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from 'bun:test';
+import { PGLiteEngine } from '../src/core/pglite-engine.ts';
+import { redactSession } from '../src/core/transcripts/render.ts';
+import { TRANSCRIPT_SECRET_AUDIT_VERSION, auditTranscriptSecrets } from '../src/core/transcripts/secret-audit.ts';
+import type { ParsedSession } from '../src/core/transcripts/types.ts';
+import { resetPgliteState } from './helpers/reset-pglite.ts';
+import { COOKIE_PROSE_NEGATIVES } from './fixtures/transcripts/synthetic-credentials.ts';
+
+const SID = ['SYNTH', 'cookieA0001fake'].join('');
+const CSRF = ['SYNTH', 'cookieB0002fake'].join('');
+
+function redact(texts: string[]): string[] {
+ const session: ParsedSession = {
+ meta: { harness: 'claude-code', sessionId: 'cookie-0001', startedAt: '2026-10-06T09:00:00.000Z' },
+ messages: texts.map((text, i) => ({ role: 'user', timestamp: `2026-10-06T09:00:0${i}.000Z`, text })),
+ };
+ return redactSession(session, { patterns: [] }).session.messages.map((m) => m.text);
+}
+const one = (text: string): string => redact([text])[0]!;
+
+describe('cookie_header: cookie values are redacted, names kept', () => {
+ const cases: Array<[string, string, string]> = [
+ ['curl -H Cookie with two pairs', `curl -H 'Cookie: sid=${SID}; csrf=${CSRF}' https://app.acme-example.test/`, `curl -H 'Cookie: sid=<REDACTED:cookie_header>; csrf=<REDACTED:cookie_header>' https://app.acme-example.test/`],
+ ['curl -H "cookie:" lower case', `curl -H "cookie: sid=${SID}" https://app.acme-example.test/`, `curl -H "cookie: sid=<REDACTED:cookie_header>" https://app.acme-example.test/`],
+ ['raw request header line', `Cookie: sid=${SID}; lang=en`, `Cookie: sid=<REDACTED:cookie_header>; lang=en`],
+ ['Set-Cookie keeps its attributes', `Set-Cookie: sid=${SID}; Path=/; HttpOnly; Secure; Max-Age=3600`, `Set-Cookie: sid=<REDACTED:cookie_header>; Path=/; HttpOnly; Secure; Max-Age=3600`],
+ ['quoted cookie value', `Set-Cookie: sid="${SID}"; Path=/`, `Set-Cookie: sid="<REDACTED:cookie_header>"; Path=/`],
+ ['curl -b', `curl -b 'sid=${SID}; csrf=${CSRF}' https://app.acme-example.test/`, `curl -b 'sid=<REDACTED:cookie_header>; csrf=<REDACTED:cookie_header>' https://app.acme-example.test/`],
+ ['curl --cookie=', `curl --cookie="sid=${SID}" https://app.acme-example.test/`, `curl --cookie="sid=<REDACTED:cookie_header>" https://app.acme-example.test/`],
+ ['copy as fetch JSON', `{"headers": {"cookie": "sid=${SID}; csrf=${CSRF}"}}`, `{"headers": {"cookie": "sid=<REDACTED:cookie_header>; csrf=<REDACTED:cookie_header>"}}`],
+ ['escaped JSON in a tool call', `{"command": "curl -H \"Cookie: sid=${SID}\" https://app.acme-example.test/"}`, `{"command": "curl -H \"Cookie: sid=<REDACTED:cookie_header>\" https://app.acme-example.test/"}`],
+ ];
+ for (const [name, input, expected] of cases) {
+ test(name, () => {
+ const out = one(input);
+ expect(out).toBe(expected);
+ expect(out).not.toContain(SID);
+ expect(out).not.toContain(CSRF);
+ });
+ }
+
+ test('an apostrophe inside an earlier cookie does not stop parsing', () => {
+ expect(one(`Cookie: theme=ab'cd; sid=${SID}`)).toBe("Cookie: theme=ab'cd; sid=<REDACTED:cookie_header>");
+ });
+ test('a percent-encoded value is redacted, not taken for a placeholder', () => {
+ expect(one(`Cookie: sid=%2F${SID}`)).toBe('Cookie: sid=<REDACTED:cookie_header>');
+ });
+ test('a value holding a comma or a JSON-escaped slash is redacted whole', () => {
+ expect(one(`Cookie: sid=${SID},${CSRF}`)).toBe('Cookie: sid=<REDACTED:cookie_header>');
+ expect(one(`{"cookie": "sid=abc\\/${SID}"}`)).toBe('{"cookie": "sid=<REDACTED:cookie_header>"}');
+ });
+ test('curl -b far into a long command line is still a cookie', () => {
+ const out = one(`curl -H "X-Trace: ${'t'.repeat(600)}" -b 'sid=${SID}' https://app.acme-example.test/`);
+ expect(out).not.toContain(SID);
+ expect(out).toContain("-b 'sid=<REDACTED:cookie_header>'");
+ });
+ test('many cookie values never crowd a later password out of the echo pass', () => {
+ const PW = ['Synth', 'Labeled4242pw'].join('');
+ const jar = Array.from({ length: 70 }, (_, i) => `c${i}=${['SYNTH', 'jarvalue', String(i).padStart(4, '0')].join('')}`).join('; ');
+ const out = redact([`Cookie: ${jar}`, `password: ${PW}`, `I typed ${PW} again`]);
+ expect(out[0]).not.toContain('SYNTHjarvalue');
+ expect(out[1]).toMatch(/^password: <REDACTED:[a-z_]+>$/);
+ expect(out[2]).toMatch(/^I typed <REDACTED:[a-z_]+> again$/);
+ });
+ test('a cookie value echoed in a later message is scrubbed too', () => {
+ const out = redact([`Cookie: sid=${SID}`, `the session id is ${SID} right?`]);
+ expect(out.join('\n')).not.toContain(SID);
+ });
+
+ test('a cookie value in a speaker label and raw metadata is redacted', () => {
+ const session: ParsedSession = {
+ meta: { harness: 'claude-code', sessionId: 'cookie-0002', raw: { request: `Cookie: sid=${SID}` } },
+ messages: [{ role: 'user', speaker: `Cookie: sid=${SID}`, timestamp: '2026-10-06T09:00:00.000Z', text: 'hello' }],
+ };
+ const out = JSON.stringify(redactSession(session, { patterns: [] }).session);
+ expect(out).not.toContain(SID);
+ expect(out).toContain('<REDACTED:cookie_header>');
+ });
+});
+
+describe('cookie_header: prose, placeholders and short preference values stay', () => {
+ for (const text of COOKIE_PROSE_NEGATIVES) {
+ test(JSON.stringify(text), () => expect(one(text)).toBe(text));
+ }
+ test('short preference values (theme=dark) are not claimed', () => {
+ expect(one('Cookie: theme=dark; lang=en')).toBe('Cookie: theme=dark; lang=en');
+ });
+ test('a -b flag outside a curl command is not a cookie', () => {
+ expect(one('git checkout -b feature=abcdefgh12345')).toBe('git checkout -b feature=abcdefgh12345');
+ });
+ test('curl -b with a cookie-jar file name is left alone', () => {
+ expect(one('curl -b cookies.txt -c cookies.txt https://app.acme-example.test/')).toBe('curl -b cookies.txt -c cookies.txt https://app.acme-example.test/');
+ });
+});
+
+describe('audit-secrets uses the transcript-lane rules', () => {
+ let engine: PGLiteEngine;
+ beforeAll(async () => {
+ engine = new PGLiteEngine();
+ await engine.connect({});
+ await engine.initSchema();
+ });
+ afterAll(async () => {
+ await engine.disconnect();
+ });
+ beforeEach(async () => {
+ await resetPgliteState(engine);
+ });
+
+ test('a stored page with a cookie header is affected; the audit version moved to 6', async () => {
+ await engine.putPage('conversations/sessions/2026-01-02-codex-cccccccccccc', {
+ type: 'conversation', title: 'session', compiled_truth: `intro\ncurl -H 'Cookie: sid=${SID}' https://app.acme-example.test/`,
+ frontmatter: { transcript_import: { harness: 'codex', session_id: 'cookie' } },
+ });
+ const result = await auditTranscriptSecrets(engine);
+ expect(result.by_pattern).toEqual({ cookie_header: 1 });
+ expect(result.pages[0]!.lines).toEqual([2]);
+ expect(JSON.stringify(result)).not.toContain(SID);
+ expect(TRANSCRIPT_SECRET_AUDIT_VERSION).toBe(6);
+ });
+});
diff --git a/test/transcripts-secret-corpus.test.ts b/test/transcripts-secret-corpus.test.ts
new file mode 100644
index 0000000000..3514e94133
--- /dev/null
+++ b/test/transcripts-secret-corpus.test.ts
@@ -0,0 +1,55 @@
+/**
+ * GST-2768 PR 1: every detector kind, in the shapes a pasted agent session
+ * carries them, is redacted by the transcript lane (redactSession) wherever
+ * the importer persists text: message bodies, speaker labels, the title and
+ * raw metadata values. The corpus is synthetic
+ * (test/fixtures/transcripts/synthetic-credentials.ts).
+ */
+import { describe, expect, test } from 'bun:test';
+import { NAMED_SECRET_RULES } from '../src/core/secret-scan.ts';
+import { redactSession } from '../src/core/transcripts/render.ts';
+import type { ParsedSession } from '../src/core/transcripts/types.ts';
+import { SYNTHETIC_CREDENTIAL_CORPUS } from './fixtures/transcripts/synthetic-credentials.ts';
+
+const TS = (i: number): string => `2026-10-06T09:00:${String(i).padStart(2, '0')}.000Z`;
+
+function run(session: ParsedSession): string {
+ return JSON.stringify(redactSession(session, { patterns: [] }).session);
+}
+
+describe('synthetic credential corpus', () => {
+ test('covers every named rule plus the transcript-lane kinds', () => {
+ const kinds = new Set(SYNTHETIC_CREDENTIAL_CORPUS.map((e) => e.kind));
+ for (const k of [...NAMED_SECRET_RULES, 'high_entropy_assignment', 'labeled_credential', 'cookie_header']) expect([k, kinds.has(k)]).toEqual([k, true]);
+ expect(SYNTHETIC_CREDENTIAL_CORPUS.some((e) => e.messages.length > 1)).toBe(true);
+ });
+
+ test('a quoted .netrc password is redacted', () => {
+ const pw = ['Synth', 'Netrc98765'].join('');
+ const out = run({ meta: { harness: 'claude-code', sessionId: 'netrc-quoted' }, messages: [{ role: 'user', timestamp: TS(0), text: `machine api.acme-example.test login alice-example password "${pw}"` }] });
+ expect(out).not.toContain(pw);
+ expect(out).toContain('password \\"<REDACTED:labeled_credential>\\"');
+ });
+
+ for (const e of SYNTHETIC_CREDENTIAL_CORPUS) {
+ test(`${e.id} (${e.shape}) in message bodies`, () => {
+ const out = run({
+ meta: { harness: 'claude-code', sessionId: e.id },
+ messages: e.messages.map((text, i) => ({ role: i % 2 === 0 ? 'user' : 'assistant', timestamp: TS(i), text })),
+ });
+ for (const s of e.secrets) expect([e.id, out.includes(s)]).toEqual([e.id, false]);
+ expect(out).toContain(`<REDACTED:${e.kind}>`);
+ });
+
+ if (e.messages.length > 1) continue;
+ const text = e.messages[0]!;
+ test(`${e.id} in a speaker label, the title and raw metadata`, () => {
+ const out = run({
+ meta: { harness: 'claude-code', sessionId: e.id, title: text, raw: { note: text, nested_ok: 1 } },
+ messages: [{ role: 'user', speaker: text, timestamp: TS(0), text: 'hello' }],
+ });
+ for (const s of e.secrets) expect([e.id, out.includes(s)]).toEqual([e.id, false]);
+ expect(out.split(`<REDACTED:${e.kind}>`).length - 1).toBeGreaterThanOrEqual(3);
+ });
+ }
+});
diff --git a/test/transcripts-secret-cross-message.test.ts b/test/transcripts-secret-cross-message.test.ts
new file mode 100644
index 0000000000..c21ecad477
--- /dev/null
+++ b/test/transcripts-secret-cross-message.test.ts
@@ -0,0 +1,86 @@
+/**
+ * GST-2768 PR 1: a credential label in one message ("here is my API key:",
+ * "password:", "login: alice /") whose value arrives alone in the NEXT
+ * message reached the conversation page verbatim, because each message was
+ * scanned on its own. Same for a key or token label at the end of a line
+ * with the value alone on the next line (only password and login labels
+ * carried to the next line before). The transcript lane now joins them,
+ * bounded to the first line of the next message. Values are synthetic.
+ */
+import { describe, expect, test } from 'bun:test';
+import { redactSession } from '../src/core/transcripts/render.ts';
+import type { ParsedSession } from '../src/core/transcripts/types.ts';
+
+const KEY = ['Synth3tic', 'ApiKeyValue0042'].join('');
+const PW = ['Synth', '-pw-split-9'].join('');
+const PAIR = ['Synth', '-pair-5x'].join('');
+const TOKEN = ['Synth3tic', 'Tok3nValue0099'].join('');
+
+function redact(texts: string[], roles: Array<'user' | 'assistant'> = []): string[] {
+ const session: ParsedSession = {
+ meta: { harness: 'claude-code', sessionId: 'cross-0001', startedAt: '2026-10-06T09:00:00.000Z' },
+ messages: texts.map((text, i) => ({ role: roles[i] ?? 'user', timestamp: `2026-10-06T09:00:0${i}.000Z`, text })),
+ };
+ return redactSession(session, { patterns: [] }).session.messages.map((m) => m.text);
+}
+
+describe('a label in one message, its value in the next', () => {
+ test('API key label, then the key alone', () => {
+ expect(redact(['here is my API key:', KEY])).toEqual(['here is my API key:', '<REDACTED:labeled_credential>']);
+ });
+ test('password label, then the password alone', () => {
+ expect(redact(['password:', PW])).toEqual(['password:', '<REDACTED:labeled_credential>']);
+ });
+ test('login pair with the password in the next message', () => {
+ expect(redact(['login: alice-example /', PAIR])).toEqual(['login: alice-example /', '<REDACTED:labeled_credential>']);
+ });
+ test('an assistant prompt, then the user pastes the token', () => {
+ expect(redact(['Paste your access token:', TOKEN], ['assistant', 'user'])[1]).toBe('<REDACTED:labeled_credential>');
+ });
+ test('only the first line of the next message is read', () => {
+ const out = redact(['password:', `${PW}\nand the rest of the note`]);
+ expect(out[1]).toBe('<REDACTED:labeled_credential>\nand the rest of the note');
+ });
+ test('a NUL after the label does not defeat the join', () => {
+ expect(redact(['password:\u0000', PW])).toEqual(['password:', '<REDACTED:labeled_credential>']);
+ });
+ test('blank lines before the value in the next message are skipped', () => {
+ expect(redact(['here is my API key:', `\n\n${KEY}`])[1]).toBe('\n\n<REDACTED:labeled_credential>');
+ });
+ test('the joined value is scrubbed where it is echoed later', () => {
+ const out = redact(['here is my API key:', KEY, `I set it to ${KEY} in the config`]);
+ expect(out.join('\n')).not.toContain(KEY);
+ });
+});
+
+describe('a key or token label at the end of a line, the value on the next', () => {
+ test('access token label', () => {
+ expect(redact([`ok, the access token:\n${TOKEN}`])[0]).toBe('ok, the access token:\n<REDACTED:labeled_credential>');
+ });
+ test('API key label in an env-style note', () => {
+ expect(redact([`OpenAI api key:\n ${KEY}`])[0]).toBe('OpenAI api key:\n <REDACTED:labeled_credential>');
+ });
+});
+
+describe('bounded lookahead and prose stay intact', () => {
+ test('a value two messages later is not joined', () => {
+ expect(redact(['password:', 'one sec', PW])).toEqual(['password:', 'one sec', PW]);
+ });
+ test('prose after a key label is not claimed', () => {
+ expect(redact(['here is my API key:', 'hold on, looking for it'])).toEqual(['here is my API key:', 'hold on, looking for it']);
+ expect(redact(['Next token:', 'Thanks'])).toEqual(['Next token:', 'Thanks']);
+ expect(redact([`the secret:\nnothing to see`])).toEqual([`the secret:\nnothing to see`]);
+ });
+ test('a short or letter-only word after a key label is not claimed', () => {
+ expect(redact(['api key:', 'missing'])).toEqual(['api key:', 'missing']);
+ expect(redact(['token:', 'abc123'])).toEqual(['token:', 'abc123']);
+ });
+ test('a file path or version after a key label is not claimed', () => {
+ expect(redact(['token:', 'src/core/foo1.ts'])).toEqual(['token:', 'src/core/foo1.ts']);
+ expect(redact([`the token:\nconfig2024.json`])).toEqual([`the token:\nconfig2024.json`]);
+ expect(redact(['token:', 'v2.1.0-rc1-build'])).toEqual(['token:', 'v2.1.0-rc1-build']);
+ });
+ test('a code identifier after a key label is not claimed', () => {
+ expect(redact(['the token:', 'process.env.API_TOKEN_V2'])).toEqual(['the token:', 'process.env.API_TOKEN_V2']);
+ });
+});