From 80f0220ae143eb101e2fbbb03af7e883577baf00 Mon Sep 17 00:00:00 2001 From: Rongjun GENG Date: Thu, 15 Oct 2026 04:51:00 -0700 Subject: [PATCH 1/2] fix(workapi): refuse YamlOnlyKey writes through the settings HTTP surface MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit bd config set already refuses a write to a YamlOnlyKey (startup flags and the tracker secrets: github.token, linear.api_key, jira.api_token, gitlab.token, ado.pat) via config.IsYamlOnlyKey at its own door. The other door onto the same plane — the settings HTTP surface bd serve and its dashboard expose, PUT /v0/beads/config/{key}, which reaches ValidateSettingWrite through internal/storage/uow and internal/workapi/storeworkspaceconfig — had no such rule. A secret PUT through it landed as a plain row in the Dolt config table, which is synced (bd dolt push/pull, DOLT_CLONE, DOLT_PULL replicate it), so the secret reached every remote on the next push. Add the same config.IsYamlOnlyKey check to ValidateSettingWrite, following the precedent already set there for issue_prefix ("refused here rather than at the front door because bd config set is not the only door that reaches this plane"). The check is unconditional, not narrowed to secrets: a non-secret YamlOnlyKey succeeding through this door is the same GH#536 class of bug the map exists to prevent (a write that reports success but that no reader ever consults). The error only echoes the key, never the submitted value. Fixes gastownhall/beads#7559 Verified: go build/vet clean; the new test fails against the unfixed file (confirmed via git stash) and passes restored; the existing internal/workapi suite (9 prior tests, including the two filters that share this file) is unchanged. Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_01VN2SgXAHW1eTB1izwWwmyr --- internal/workapi/workspaceconfig.go | 16 ++++++++++++ internal/workapi/workspaceconfig_test.go | 31 ++++++++++++++++++++++++ 2 files changed, 47 insertions(+) diff --git a/internal/workapi/workspaceconfig.go b/internal/workapi/workspaceconfig.go index 1ca797ad9..cc713b3df 100644 --- a/internal/workapi/workspaceconfig.go +++ b/internal/workapi/workspaceconfig.go @@ -4,6 +4,7 @@ import ( "fmt" "strings" + "github.com/steveyegge/beads/internal/config" "github.com/steveyegge/beads/internal/storage/kvkeys" "github.com/steveyegge/beads/internal/types" "github.com/steveyegge/beads/issueops" @@ -42,6 +43,21 @@ func ValidateSettingWrite(key, value string) (string, error) { if _, err := ValidateSettingKey(key); err != nil { return "", err } + // config.YamlOnlyKeys — startup settings and the tracker secrets + // (github.token, linear.api_key, jira.api_token, gitlab.token, ado.pat) — + // must live in the workspace's local config.yaml, never in this plane's + // row-per-key storage: that storage is the Dolt config table, which is a + // SYNCED table (bd dolt push/pull, DOLT_CLONE, DOLT_PULL all replicate + // it). `bd config set` already refuses these at its own door; this is + // the only other door onto this plane (the settings HTTP surface bd + // serve and its dashboard expose), and it had no such rule, so a secret + // PUT through it landed in the synced table and reached every remote on + // the next push (GH#7559). + if config.IsYamlOnlyKey(key) { + return "", fmt.Errorf("%w: %q must be set in the workspace's local config.yaml (bd config set %s ), not written here: "+ + "this plane is the Dolt config table, which syncs to every remote on push/pull", + issueops.ErrValidation, key, key) + } // The prefix is owned by bd init --prefix, bd bootstrap and bd // rename-prefix. Refused HERE rather than at the front door because `bd // config set` is not the only door that reaches this plane: before this diff --git a/internal/workapi/workspaceconfig_test.go b/internal/workapi/workspaceconfig_test.go index 3cef62b5c..816b621a5 100644 --- a/internal/workapi/workspaceconfig_test.go +++ b/internal/workapi/workspaceconfig_test.go @@ -57,6 +57,37 @@ func TestValidateSettingWriteRefusesTheProtectedKeyInBothSpellings(t *testing.T) } } +// TestValidateSettingWriteRefusesYamlOnlyKeys pins GH#7559: `bd config set` +// already refuses a YamlOnlyKey write via config.IsYamlOnlyKey at its own +// door, but this plane's HTTP settings surface (bd serve and its dashboard, +// PUT /v0/beads/config/{key}) had no such rule, so a tracker secret +// (github.token, linear.api_key, jira.api_token, gitlab.token, ado.pat) sent +// through it landed as a plain row in the Dolt config table — a SYNCED +// table, replicated to every remote on the next bd dolt push/pull. The +// PoC's five secret keys, plus a non-secret YamlOnlyKey (the exact GH#536 +// shape the map exists to prevent: a write that reports success but no +// reader ever consults), must all be refused here now. +func TestValidateSettingWriteRefusesYamlOnlyKeys(t *testing.T) { + for _, key := range []string{ + // The PoC's five secrets. + "github.token", "linear.api_key", "jira.api_token", "gitlab.token", "ado.pat", + // A non-secret YamlOnlyKey: the rule is "this plane is the database, + // these settings are not database settings", not "secrets only". + "no-db", + } { + _, err := ValidateSettingWrite(key, "SECRET-OR-SETTING-VALUE") + if !errors.Is(err, issueops.ErrValidation) { + t.Fatalf("ValidateSettingWrite(%q) error = %v, want ErrValidation", key, err) + } + if strings.Contains(err.Error(), "SECRET-OR-SETTING-VALUE") { + t.Errorf("ValidateSettingWrite(%q) error echoes the value %v; a secret must never appear in an error message", key, err) + } + if !strings.Contains(err.Error(), "config.yaml") { + t.Errorf("ValidateSettingWrite(%q) message %q does not point the caller at config.yaml", key, err) + } + } +} + func TestValidateSettingWriteParsesTheCustomStatusValue(t *testing.T) { for _, value := range []string{ "awaiting_review", From 53eb1287ed540dc96d81319d117494a8a1c117e4 Mon Sep 17 00:00:00 2001 From: Rongjun GENG Date: Fri, 16 Oct 2026 04:25:37 -0700 Subject: [PATCH 2/2] fix(httpclient): close the third door onto the settings plane, fix stale doctrine MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Maintainer review (bee-ghosttrack) on PR #7567 found CI red at 80f0220ae that the original fix missed a third door onto the settings plane: internal/httpclient carries its own client-side mirror of workapi.ValidateSettingWrite (validateSettingWrite in roles_aux.go), pinned to match it by TestSettingWriteValidationMatchesTheSharedValidator. Give it the same config.IsYamlOnlyKey check, so all three doors — bd config set, the server-side role, and this client — refuse the same set. Two tests broke as a direct result, both fixed: - TestSettingWriteValidationMatchesTheSharedValidator's "an ordinary key" case used routing.default, which IsYamlOnlyKey now matches by its routing. prefix. Swapped to a genuinely ordinary key (notes) and added two new rows pinning the new refusal arm (an exact-match secret and a prefix-match family). - TestServedConfigWriteAnswersTheReadThatFollowsIt wrote notion.token through a real served bd serve expecting PERMITTED + redacted-answer; flipped to expect refusal and confirmed nothing lands in the reference store. The read-side redaction doctrine is untouched (a GetSetting on a credential-bearing key still withholds unconditionally, keyed on the key pattern rather than on store presence) and stays pinned as before. Found and fixed the same root cause in a third place the review didn't need to name, since it follows from the same two swapped keys: TestSetSettingTranscribesTheAnswerRatherThanEchoingTheRequest drove its "plain" and "redacted" arms through SetSetting with routing.default and notion.token respectively — both now refused client-side before the fake transport is ever reached. Swapped both to ordinary keys (notes, custom.thing); the redacted/not-redacted branch is driven by the fake answer's own Redacted field, not by the key name, so the property under test is unaffected. Updated stale doctrine the review flagged as now false: internal/notion/auth.go's ResolveAuth comment claimed "one door is still open" (tracked as a follow-up to GH#6676) — that door is this PR. internal/httpapi/settings_write_test.go's TestSetSettingWithholdsACredentialItJustAccepted and TestSetSettingAnswersWhatTheReadWouldAnswer run against a fake role that still accepts any write (so they pass unchanged), but their comments stated the old doctrine as fact; reworded to say what they actually exercise now (the redaction projection in isolation) and that a real role refuses these keys before this projection runs. Verified: go build ./..., go vet on every touched package — clean. internal/workapi, internal/httpapi, internal/notion — full suites green. internal/httpclient — full suite green both without and with BEADS_TEST_EMBEDDED_DOLT=1 (the served tier). The three directly-hit unit tests individually confirmed against the real behavior (not just assumed): TestServedConfigWriteAnswersTheReadThatFollowsIt run live against a real embedded-Dolt bd serve to confirm the exact refusal and read-side behavior before writing the final assertions, since an earlier draft of that assertion (read answers like an absent key) was empirically wrong and had to be corrected to match real behavior (read still withholds unconditionally; only the write's permit/refuse flips). Addresses PR #7567 review feedback on gastownhall/beads#7559 Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_01VN2SgXAHW1eTB1izwWwmyr --- internal/httpapi/settings_write_test.go | 29 +++++--- internal/httpclient/roles_aux.go | 13 ++++ .../httpclient/served_config_write_test.go | 69 ++++++++----------- internal/httpclient/wave2c_config_test.go | 26 +++++-- internal/notion/auth.go | 15 ++-- 5 files changed, 87 insertions(+), 65 deletions(-) diff --git a/internal/httpapi/settings_write_test.go b/internal/httpapi/settings_write_test.go index 4deeab462..82443f9f0 100644 --- a/internal/httpapi/settings_write_test.go +++ b/internal/httpapi/settings_write_test.go @@ -139,6 +139,13 @@ func TestSetSettingProjectsTheWholeRequest(t *testing.T) { // one place — and `Setting.redacted` would mean two different things depending on // which operation produced it. Comparing the two responses is what makes a second // projection impossible to add without failing here. +// +// THE CREDENTIAL-BEARING CASE RUNS AGAINST A FAKE ROLE (`&roleSettings{}`, +// which accepts any write), not workapi.ValidateSettingWrite. Since GH#7559 +// the real role refuses notion.token — and every other config.IsYamlOnlyKey +// key — before this projection ever runs, so this case now exercises only the +// redaction PROJECTION in isolation: if a real server's role ever did accept +// a credential write, this is the shape the response would have to take. func TestSetSettingAnswersWhatTheReadWouldAnswer(t *testing.T) { for _, tc := range []struct { name string @@ -146,7 +153,7 @@ func TestSetSettingAnswersWhatTheReadWouldAnswer(t *testing.T) { value string }{ {name: "an ordinary key", key: "status.custom", value: "awaiting_review:active"}, - {name: "a credential-bearing key", key: "notion.token", value: "shhh-real-secret"}, + {name: "a credential-bearing key, against a fake role that accepts it", key: "notion.token", value: "shhh-real-secret"}, {name: "a key stored empty", key: "notes", value: ""}, } { t.Run(tc.name, func(t *testing.T) { @@ -173,15 +180,19 @@ func TestSetSettingAnswersWhatTheReadWouldAnswer(t *testing.T) { } // TestSetSettingWithholdsACredentialItJustAccepted is the doctrine, asserted -// directly rather than only through the equality above: the write is PERMITTED -// and the value does not come back. +// directly rather than only through the equality above: AGAINST A ROLE THAT +// ACCEPTS THE WRITE, the response is PERMITTED and the value does not come +// back. // -// PERMITTED because redaction is a rule about DISCLOSURE. The role refuses no -// credential-bearing key — `bd config set`'s own secret guard is about writing -// one into a git-tracked config.yaml, a different plane with a different hazard — -// and a writer already holds the value, so refusing here would protect nothing -// while leaving a workspace's credentials visible as PRESENT and permanently -// unconfigurable through this door. +// IT RUNS AGAINST A FAKE ROLE (`&roleSettings{}`), not +// workapi.ValidateSettingWrite. Since GH#7559 the real role refuses every +// config.IsYamlOnlyKey key — including every tracker credential, writing +// them to a git-tracked config.yaml instead via `bd config set`'s own guard +// — because that plane is the Dolt config table, synced to every remote on +// push/pull. What this test pins is narrower: IF a role's write succeeds, +// the HTTP layer's redaction projection must withhold the value from its own +// answer regardless, which is what the handler owns and the only part of +// this doctrine the httpapi package can prove on its own. func TestSetSettingWithholdsACredentialItJustAccepted(t *testing.T) { const key = "notion.token" if !config.IsSecretKey(key) { diff --git a/internal/httpclient/roles_aux.go b/internal/httpclient/roles_aux.go index 213224d12..4a1a8f1ab 100644 --- a/internal/httpclient/roles_aux.go +++ b/internal/httpclient/roles_aux.go @@ -9,6 +9,7 @@ import ( "net/url" "strings" + "github.com/steveyegge/beads/internal/config" "github.com/steveyegge/beads/internal/httpapi/apigen" "github.com/steveyegge/beads/internal/httpclient/wire" "github.com/steveyegge/beads/internal/types" @@ -241,6 +242,18 @@ func validateSettingWrite(key, value string) error { if err := validateSettingKey(key); err != nil { return err } + // config.YamlOnlyKeys — startup settings and the tracker secrets — must + // live in the workspace's local config.yaml, never in this plane's + // row-per-key storage, which is the Dolt config table: a SYNCED table + // replicated to every remote on push/pull. `bd config set` already + // refuses these at its own door; this mirror and the server-side + // workapi.ValidateSettingWrite it is pinned to (wave2c_config_test.go's + // TestSettingWriteValidationMatchesTheSharedValidator) are two more doors + // onto the same plane and must refuse the same set (GH#7559). + if config.IsYamlOnlyKey(key) { + return invalid("%q must be set in the workspace's local config.yaml (bd config set %s ), not written here: "+ + "this plane is the Dolt config table, which syncs to every remote on push/pull", key, key) + } // The prefix is owned by `bd init --prefix`, `bd bootstrap` and // `bd rename-prefix`, each of which does work this plane cannot: rewriting // existing ids, or seeding a workspace that has none. Storing a new one here diff --git a/internal/httpclient/served_config_write_test.go b/internal/httpclient/served_config_write_test.go index 3596dff56..04d49a9f9 100644 --- a/internal/httpclient/served_config_write_test.go +++ b/internal/httpclient/served_config_write_test.go @@ -26,29 +26,20 @@ import ( // SERVER's, and a stub transport would let this file assert whatever it liked // about them. -// TestServedConfigWriteAnswersTheReadThatFollowsIt is the redaction doctrine, -// pinned on both sides of the one key it changes anything for. +// TestServedConfigWriteAnswersTheReadThatFollowsIt pins GH#7559 end to end +// against a real served role, beside the unrelated transcription property the +// ordinary key below it was always here to prove. // -// The operation PERMITS a credential-bearing write and WITHHOLDS the value from -// its own answer — one projection serves the write and the read, so the body of -// a PUT is byte-identical to the body of the GET after it. That leaves a -// successful write whose `value` member is absent, and the role's result has no -// spelling for "withheld": reporting "" would tell a caller the plane holds -// nothing under that key, which is the write-side version of the confusion -// RedactedSettingError exists to prevent on the read side. -// -// So the client answers with the value it SENT, and this asserts why that is -// honest rather than convenient: the value really is stored, read RAW from the -// reference store past the wire that hid it. -// -// WHAT THIS CASE CANNOT SAY is that the ordinary key beside it is TRANSCRIBED -// off the answer rather than echoed from the request. Against a correct server -// the two are byte-identical — the operation promises the stored value equals -// the value sent for every key it accepts — so the difference is pinned where it -// is observable, against a transport that answers something else: -// TestSetSettingTranscribesTheAnswerRatherThanEchoingTheRequest. The ordinary -// key runs here anyway, because a client that transcribed the WRONG member would -// fail it. +// BEFORE GH#7559 this case pinned the redaction doctrine: a credential-bearing +// write was PERMITTED and only the ANSWER withheld the value. That doctrine +// was wrong for this door — the credential landed in the Dolt config table, +// a table `bd dolt push`/pull replicates to every remote — so the fix refuses +// the write instead of merely hiding its result. There is nothing left for +// this case to prove about REDACTION on a key workapi.ValidateSettingWrite now +// refuses outright; the httpapi package's fake-role tests +// (TestSetSettingAnswersWhatTheReadWouldAnswer, TestSetSettingWithholdsACredentialItJustAccepted) +// keep pinning what the redaction PROJECTION does if a role ever did accept +// such a write. func TestServedConfigWriteAnswersTheReadThatFollowsIt(t *testing.T) { e := newServedEnv(t, "hcfgw1") ctx := t.Context() @@ -56,32 +47,28 @@ func TestServedConfigWriteAnswersTheReadThatFollowsIt(t *testing.T) { const secretKey = "notion.token" const secret = "shhh-real-secret" - res, err := settings.SetSetting(ctx, issueops.SetSettingRequest{Key: secretKey, Value: secret}) - if err != nil { - t.Fatalf("SetSetting on a credential-bearing key = %v; the write is permitted and only the ANSWER withholds", err) - } - if res.Key != secretKey { - t.Errorf("SetSetting echoed key %q, want %q", res.Key, secretKey) - } - if res.Value != secret { - t.Errorf("SetSetting reported value %q, want %q: the answer withheld it, and \"\" would say the plane stores nothing there", - res.Value, secret) + _, err := settings.SetSetting(ctx, issueops.SetSettingRequest{Key: secretKey, Value: secret}) + if !errors.Is(err, issueops.ErrValidation) { + t.Fatalf("SetSetting on a credential-bearing key = %v, want ErrValidation: "+ + "this plane is the Dolt config table, synced to every remote on push/pull", err) } - // Read RAW, past the role and past the wire: the point is that the value the - // response would not repeat IS the value the workspace now holds. + // Read RAW, past the role and past the wire: nothing was written. stored, err := e.reference.GetConfig(ctx, secretKey) if err != nil { - t.Fatalf("read the stored credential back from the reference store: %v", err) + t.Fatalf("read the reference store for the key that must not have been written: %v", err) } - if stored != secret { - t.Errorf("the workspace stores %q under %q, want %q", stored, secretKey, secret) + if stored != "" { + t.Errorf("the workspace stores %q under %q, want nothing: the refused write must not have reached the store", stored, secretKey) } - // And the READ that follows still withholds, which is the other half of "the - // PUT body is the GET body": a write does not unlock the key it just wrote. + // The READ side is unchanged by this fix and keeps its own doctrine: a + // GetSetting on a credential-bearing key withholds unconditionally, keyed + // on the KEY pattern rather than on whether anything is actually stored + // there — confirmed empirically (this is not something the write-side fix + // touches, so the refused write above leaves it exactly as it always was). if _, err := settings.GetSetting(ctx, issueops.GetSettingRequest{Key: secretKey}); !errors.Is(err, ErrSettingRedacted) { - t.Errorf("GetSetting after the write = %v, want ErrSettingRedacted; the write does not unlock the read", err) + t.Errorf("GetSetting on a credential-bearing key = %v, want ErrSettingRedacted regardless of whether a write ever reached the store", err) } // The ordinary key is TRANSCRIBED, not echoed. The server answers this one @@ -90,7 +77,7 @@ func TestServedConfigWriteAnswersTheReadThatFollowsIt(t *testing.T) { // something else. const plainKey = "custom.hcfgw1-plain" const plain = " spaces and , commas " - res, err = settings.SetSetting(ctx, issueops.SetSettingRequest{Key: plainKey, Value: plain}) + res, err := settings.SetSetting(ctx, issueops.SetSettingRequest{Key: plainKey, Value: plain}) if err != nil { t.Fatalf("SetSetting on an ordinary key: %v", err) } diff --git a/internal/httpclient/wave2c_config_test.go b/internal/httpclient/wave2c_config_test.go index 300233fba..42affd8de 100644 --- a/internal/httpclient/wave2c_config_test.go +++ b/internal/httpclient/wave2c_config_test.go @@ -47,7 +47,7 @@ func TestSettingWriteValidationMatchesTheSharedValidator(t *testing.T) { key string value string }{ - {"an ordinary key", "routing.default", "core"}, + {"an ordinary key", "notes", "core"}, {"an empty key", "", "x"}, {"a blank key", " ", "x"}, {"the protected key", issueops.SettingKeyIssuePrefix, "bd"}, @@ -57,6 +57,10 @@ func TestSettingWriteValidationMatchesTheSharedValidator(t *testing.T) { {"an empty custom status", issueops.SettingKeyStatusCustom, ""}, {"a custom type list", issueops.SettingKeyTypesCustom, "not:a:status"}, {"a key that only LOOKS protected", "issue_prefix_backup", "bd"}, + // config.IsYamlOnlyKey, GH#7559: exact-match (a tracker secret) and + // prefix-match (a whole family, e.g. routing.*) both refuse here now. + {"a yaml-only key, exact match", "github.token", "ghp_x"}, + {"a yaml-only key, prefix match", "routing.default", "core"}, } { t.Run(tc.name, func(t *testing.T) { mine := validateSettingWrite(tc.key, tc.value) @@ -203,13 +207,21 @@ func TestConfigWritesDialTheKeyInThePath(t *testing.T) { // right answer: the projection withholds the value it just accepted, so there is // nothing to transcribe and the request is the only honest source. Both arms in // one case so neither can be satisfied by a body that always does one of them. +// +// BOTH ARMS USE AN ORDINARY KEY. The redacted/not-redacted branch is driven by +// the fake answer's own Redacted field, not by the key name, and since GH#7559 +// a real credential-bearing key (or any other config.IsYamlOnlyKey key) never +// reaches this transport at all — validateSettingWrite refuses it client-side +// first. That doctrine has its own pin (TestSettingWriteValidationMatchesTheSharedValidator); +// this case is only about what the client does with the answer once a write is +// accepted. func TestSetSettingTranscribesTheAnswerRatherThanEchoingTheRequest(t *testing.T) { const sent = "what the caller sent" stored := "what the server stored" - plain := &settingAnswerWire{answer: apigen.Setting{Key: "routing.default", Value: &stored}} + plain := &settingAnswerWire{answer: apigen.Setting{Key: "notes", Value: &stored}} res, err := settingsOver(t, plain).SetSetting(context.Background(), - issueops.SetSettingRequest{Key: "routing.default", Value: sent}) + issueops.SetSettingRequest{Key: "notes", Value: sent}) if err != nil { t.Fatalf("SetSetting: %v", err) } @@ -217,15 +229,15 @@ func TestSetSettingTranscribesTheAnswerRatherThanEchoingTheRequest(t *testing.T) t.Errorf("SetSetting reported %q, want the answer's %q: the result is what the workspace holds, "+ "and echoing the request would report a value it does not", res.Value, stored) } - if res.Key != "routing.default" { + if res.Key != "notes" { t.Errorf("SetSetting reported key %q, want the answer's", res.Key) } - withheld := &settingAnswerWire{answer: apigen.Setting{Key: "notion.token", Redacted: true}} + withheld := &settingAnswerWire{answer: apigen.Setting{Key: "custom.thing", Redacted: true}} res, err = settingsOver(t, withheld).SetSetting(context.Background(), - issueops.SetSettingRequest{Key: "notion.token", Value: sent}) + issueops.SetSettingRequest{Key: "custom.thing", Value: sent}) if err != nil { - t.Fatalf("SetSetting on a credential-bearing key: %v", err) + t.Fatalf("SetSetting on an answer that redacts: %v", err) } if res.Value != sent { t.Errorf("SetSetting on a withheld answer reported %q, want the request's %q: \"\" would say the plane "+ diff --git a/internal/notion/auth.go b/internal/notion/auth.go index f8c3bb6c4..b4e5ab112 100644 --- a/internal/notion/auth.go +++ b/internal/notion/auth.go @@ -48,14 +48,13 @@ type ConfigReader interface { // clears the file and any row an older bd left behind. That matters because the // config table's contents are replicated by `bd dolt push`. // -// ONE DOOR IS STILL OPEN, and this comment deliberately does not claim -// otherwise: the routing lives in the CLI command, not at the write chokepoint, -// so PUT /v0/beads/config/notion.token — `bd serve`, and the dashboard behind -// it — still writes the row with no refusal. That hole is not Notion's; it is -// identical for github.token, jira.api_token, linear.api_key and ado.pat, which -// is why closing it belongs at the role (workapi.ValidateSettingWrite / -// SetSetting), where every tracker credential gets the rule in one change, -// rather than here. Tracked as follow-up to GH#6676. +// THE DOOR CLOSED IN GH#7559: PUT /v0/beads/config/notion.token — `bd +// serve`, and the dashboard behind it — now refuses the write at the role +// (workapi.ValidateSettingWrite and the httpclient-side mirror it is pinned +// to), the same chokepoint every tracker credential refuses through, since +// the routing used to live only in the CLI command, not at the write +// chokepoint, and github.token/jira.api_token/linear.api_key/ado.pat shared +// the identical hole. // // The database read below therefore remains, both as the upgrade path for a // workspace configured before the key moved and as the reader for anything that