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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdindex 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.mdindex 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 composedsensitivity 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.mdindex 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.mdindex 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 aplaceholder (`<…>`, `${…}`, `$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 wherethe 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; allsources, or one with `--source-id`) lists the conversation pages that stillcarry a credential: slug, source, hit count per pattern and line numbers,never the text. The doctor check `transcript_secret_exposure` reads thediff --git a/src/core/secret-scan-cookie.ts b/src/core/secret-scan-cookie.tsnew file mode 100644index 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.tsindex 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 writtendiff --git a/src/core/secret-scan.ts b/src/core/secret-scan.tsindex 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: numbeconst 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.tsindex 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.tsindex 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; primitivediff --git a/src/core/transcripts/secret-audit.ts b/src/core/transcripts/secret-audit.tsindex 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.jsonnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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']);+ });+});