Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
agent: Claude Desktop's key, sealed at rest by Desktop 4.4212, isn't said to be changed (Discord)
yetone83e41a22c940
diff --git a/docs/subsystems/agent-wiring.md b/docs/subsystems/agent-wiring.mdindex 1a24adb0d..4afcd9138 100644--- a/docs/subsystems/agent-wiring.md+++ b/docs/subsystems/agent-wiring.md@@ -89,6 +89,7 @@ something else shows up as drift.- Codex signed in to ChatGPT stays beside its sign-in (`openai_base_url`) unless the user picks magpie API. magpie becomes its provider only while the Codex app holds the active account, which it sends nothing for: `/wham/usage` says it isn't allowed, and it has no credits and isn't a workspace still within its overage (`codexHeld`, read by `provider.CodexUsedUp`). With Codex switched off or removed in magpie (`leftAlone`), whose allowance magpie otherwise reads nothing of, the active account is still read for this alone while Codex takes magpie's models beside its sign-in or magpie is its provider for the held account (`Agent.HoldMatters`, through the `provider.CodexHoldMatters` hook; `codexHoldReading`): once a minute at most, with the token as Codex keeps it, never renewed or written (`codexTokenAsKept`), and nothing shown on the Usage page. Before, turning Codex off in magpie after its allowance ran out left the Codex app greying Send for magpie's models through restarts, and one already moved was put back on the held account (sherlock_23333 on X; `TestCodexHoldReadLeftAlone`, `TestCodexHoldMatters`). Where the app goes by what usage can't show (an experiment's gate, a reserve, a Team plan's overage under the reserve experiment), it counts as held: a wrong move costs ChatGPT extras, a missed one every turn. A saved reading kept through a failed read stops saying held once its used-up window has started again; a hold with no window used up stays till a fresh read. The app then loses its ChatGPT state (durable threads, remote control), so a window at 100% alone, which credits get past, doesn't move it (`codex.out` marks the move, and Sync undoes it once the account has room). The same holds on one of Codex's own models joined beside the sign-in (MasterYi on Discord: the Codex app greyed Send for every model on a used-up account): Sync makes magpie the provider on that model as magpie serves it (`codexOwnViaMagpie`, `codex/<model>`), keeps the model picked in `codex.out_own`, and once the account has room puts Codex back joined on it; a model the user picked meanwhile stays theirs. With no ChatGPT account in magpie to serve it, Codex is left as it is (`TestCodexOwnModelGoesThroughMagpieWhileUsedUp`, `TestCodexOwnModelKeptOnChatGPT`). The account is read again at once when a reply says it may be out (a `usage_limit_reached` rest, or an `x-codex-*` window heard at 100%; `provider.CodexMayBeUsedUp`, at most every 20s, the active account only), not only on the five-minute look. A turn relayed to Codex's own sign-in, the one account on (`codexUpstreamOn` with no account, the gateway's `codexRelayedAccount`), is heard the same way: its `x-codex-*` windows and `codex.rate_limits` event kept as the sign-in's usage (`heardCodexLimits`), and a `usage_limit_reached` refusal reading it again. Before, only turns served through magpie's accounts were, so with one account magpie learned the account was out only at the next look, minutes on, and the Codex app kept Send greyed until it was restarted (unsplashz on Discord; `TestCodexUsedUpRelayedAsksAtOnce`, `TestCodexRelayedWindowsHeard`). A Codex started before magpie became its provider keeps sending its own model's turns to its built-in provider; while the sign-in is known out (`provider.CodexUsedUpKnown`) and the request signs as it, those go through routing as `codex/<model>` (`codexAccounts`), as a restarted Codex's do (`TestCodexHeldSignInServedWithoutRestart`). The Codex app greys Send for every model, magpie's too, while its `authMethod` is `chatgpt` and its rate limit says not allowed (its composer's gate in ChatGPT.app 26.1013), and reads `authMethod` from its app-server's `account/read` only as the app-server starts; with magpie the provider (`requires_openai_auth` false) that answers no account, so the gate lifts. So the gateway process restarts the app's own app-server each time magpie becomes Codex's provider for the used-up account (`Agent.AppOut`) and again when Codex is put back on the account after its reset, and likewise whenever what the app-server reads as it starts and magpie writes changes (`model_provider`, `openai_base_url`, `model_catalog_json`, the magpie table's `base_url`, and a hash of what the catalog file holds, `codexCatalogTag` in [`codex_app_route.go`](../../internal/agent/codex_app_route.go), read again only when its size or time changes; `codexAppRoute`, through the `provider.CodexAppRoute` hook): a Disconnect, a Connect, failover written or taken out, a provider or group renamed or a model added. Without the catalog in it the app kept the names and models it started with until it was restarted (lucis0116 on X). Before this an app-server started while Codex was connected kept sending to the gateway after Disconnect until the app was restarted (JiangLiuer222 on X). At the watcher's first look only a used-up account's app-servers are ended, since what the others read before magpie started isn't known. It runs on every system (`KeepCodexAppOnItsProvider`, every 3s; Ethereal499 and Isdavexxx on X, MasterYi on Discord, #540: the earlier once-only reopen ran on macOS from the GUI process only, so Windows, Linux, a GUI-less magpie and the switch back stayed greyed). It ends only app-servers on magpie's Codex home (`codexAppHomeIs`: the process's `CODEX_HOME`, else `HOME/.codex`, read by `proc.EnvOf`; Windows can't tell and counts every one), only once no Codex request is in flight through the gateway nor ended in the last 10s (`Server.CodexBusy`) and no session under the Codex home has a turn started and not ended (`codexTurnOpen`), and with a clean exit (`proc.End`: SIGTERM, `TerminateProcess` with code 0), since the app shows any other exit as a crash. The app starts another app-server at once and keeps its window, threads and drafts (tried in the real app in a sandbox `CODEX_HOME`, both ways). An app-server that outlives three ends, or may not be ended, leaves the row saying to quit and reopen the app (`CodexAppStuck`). Until the reset the app's ChatGPT side is off (cloud tasks, its usage meter, Log out); the Agents row says so with the reset's time (`appOut` in `/api/state`, `CodexOutUntil`), and it all comes back at the reset. While the active account is held or a window is at 90% or more, its usage is read every minute rather than every five (`codexLookEvery`). `TestCodexAppServerRestartedEachWay`, `TestCodexAppServerRestartedOnDisconnect`, `TestCodexAppRouteFollowsConnectAndDisconnect`, `TestCodexAppRouteFollowsTheCatalog`, `TestCodexAppServerUnknown`, `TestCodexAppServerStuck`, `TestCodexAppServersOnHome`, `TestCodexTurnOpen`, `TestCodexBusy`, `codex-app-out.test.cjs`.- Moving a field from one of magpie's models to another (the agent's own picker) is not drift. Moving it off magpie is.- Claude Desktop applying a configLibrary profile other than magpie's is not drift when that profile is a gateway profile for this magpie's gateway (`desktopAppliedGateway` in [`claudedesktop.go`](../../internal/agent/claudedesktop.go)): Desktop's "Import configuration" adds a file exported on another computer, magpie's profile there with the user's connectors (`managedMcpServers`), as a new entry under a random id (aa86222 on Discord). magpie keeps it applied on Reconnect and through Sync, and writes in it only `inferenceGatewayApiKey` (with a missing auth scheme) when the gateway would refuse its key (`desktopKeyApplied`; magpie's own keys count as taken, `desktopKeyTaken`). A profile for another gateway, CC Switch's among them, is still drift, and Reconnect applies magpie's. The first switch-on still starts magpie's profile from an applied one (#2035). `TestClaudeDesktopImportedProfileIsOnMagpie`.+- Claude Desktop 4.4212 (10-29) seals the secrets of its configLibrary profiles at rest: at every start it writes `inferenceGatewayApiKey` (and every other string secret its schema drops on export) back as `__sealed__:v1:` + base64 of `{"configLibrary":{"key":…,"value":…}}` behind `anthropic.claude.crossProfileSecret.v1:`, protected with the user's DPAPI on Windows (entropy `anthropic.claude.crossProfileSecret.v1`, claude-native's `userDpapiProtect`) and Electron's safeStorage (the Keychain) on macOS, and it sends the gateway the key as it was. `desktopOpen` ([`desktopseal.go`](../../internal/agent/desktopseal.go)) reads the key as Desktop does: on Windows it opens the seal (`desktopUnprotect`, `CryptUnprotectData`, never prompting) and judges what is in it; a seal it can't open (macOS, another user's) is unknown, so Check doesn't call it changed and `desktopKeyApplied` doesn't write over it. Before this the key read as changed after every Desktop start and Reconnect only wrote it in the clear for Desktop to seal again (a Windows user on Discord). A key in the clear that isn't one the gateway takes, a missing key and another address are still drift (`TestClaudeDesktopSealedKeyIsNotChanged`, `TestClaudeDesktopImportedSealedKeyStays`, `TestClaudeDesktopSealedKeyOpened` on Windows).- A field that follows another while empty (`Follows`: Claude Code's tiers and subagents on its main model) is read by `Drift` as on that field's model. The main model moved, in Claude Code's own `/model`, onto the model magpie had set a tier to is not drift (#1050). The tier keeps that model as its own through the move and the next one (`tier_own` in the stash), whatever it would follow on the new main model: fable, which follows no model that is no Fable, and haiku, which follows a Claude model on its Haiku, read as following and lost their model on the next move (#2257).- A Claude Code tier or its subagents given a model of their own keep it when the main model moves onto that model and on again (`ownKey` in `claudeIn`), whether the main model is picked in magpie or in Claude Code's `/model`. Same as model, picked for them, has them follow again.- While this machine's Claude Desktop is on magpie, Claude Code's shared settings get `CLAUDE_CODE_DISABLE_EXPLORE_INHERIT_CAP="1"` (`writeExplore` in `claudeIn`, [`claude.go`](../../internal/agent/claude.go)). Claude Code 2.1.295's Explore inherit cap can otherwise replace Desktop's `mythos-magpie` compatibility alias with Opus. This disables that cap, not the model choices of all subagents. It applies with Desktop alone or beside a connected Claude Code, including model picks and Sync; WSL twins do not get it. A user's existing value, including an empty string, stays. The stash (`claude.explore_inherit_cap`) marks only magpie's value: taking Claude Code off magpie leaves it while Desktop is on, and taking Desktop off removes it only if the user has not changed it. Since the settings file is shared, other Claude Code sessions reading it see the flag while Desktop is connected too.diff --git a/internal/agent/claudedesktop.go b/internal/agent/claudedesktop.goindex 0fa06913d..173de9f94 100644--- a/internal/agent/claudedesktop.go+++ b/internal/agent/claudedesktop.go@@ -251,10 +251,20 @@ func desktopCheck(p desktopPaths) string {want := agentKey("claude-desktop")return wiringOff("Claude Desktop", prof, func(k string) (string, bool) {v, ok := edit.GetJSON(prof, k)- if k == "inferenceGatewayApiKey" && prof != p.prof && desktopKeyTaken(v, want) {+ if k != "inferenceGatewayApiKey" {+ return v, ok+ }+ // Desktop seals the key at rest (desktopOpen): the one it opens+ // to is the one it sends; one magpie can't open is unknown, and+ // not said to be changed+ open, known := desktopOpen(k, v)+ if !known {+ return want, true+ }+ if prof != p.prof && desktopKeyTaken(open, want) {return want, true // a key of magpie's other than Desktop's own}- return v, ok+ return open, ok}, "inferenceGatewayBaseUrl", gateway.URL(), "inferenceGatewayApiKey", want)}@@ -298,7 +308,8 @@ func desktopAppliedGateway(p desktopPaths) string {// desktopKeyApplied gives the profile desktopAppliedGateway finds the// key magpie gives Desktop, only where the one it holds is a key this// gateway won't take (another magpie's, from the computer it was exported-// on): one it takes stays. Its address and every other setting, its+// on): one it takes stays, and so does one Desktop sealed that magpie+// can't open (desktopOpen). Its address and every other setting, its// connectors among them, stay as they are.func desktopKeyApplied(p desktopPaths) error {f := desktopAppliedGateway(p)@@ -306,7 +317,9 @@ func desktopKeyApplied(p desktopPaths) error {return nil}want := agentKey("claude-desktop")- if v, _ := edit.GetJSON(f, "inferenceGatewayApiKey"); desktopKeyTaken(v, want) {+ v, _ := edit.GetJSON(f, "inferenceGatewayApiKey")+ // a key Desktop sealed that magpie can't open is left as it is+ if open, known := desktopOpen("inferenceGatewayApiKey", v); !known || desktopKeyTaken(open, want) {return nil}kvs := []edit.KV{{Path: "inferenceGatewayApiKey", Value: want}}diff --git a/internal/agent/desktopseal.go b/internal/agent/desktopseal.gonew file mode 100644index 000000000..ef52b110d--- /dev/null+++ b/internal/agent/desktopseal.go@@ -0,0 +1,67 @@+package agent++import (+ "encoding/base64"+ "encoding/json"+ "errors"+ "strings"+)++// Claude Desktop 4.4212 (10-29) keeps the secrets of its configLibrary+// profiles encrypted at rest. At every start it sweeps configLibrary and+// writes each secret it finds in the clear (inferenceGatewayApiKey among+// them) back as+//+// "__sealed__:v1:" + base64(protect("anthropic.claude.crossProfileSecret.v1:" ++// {"configLibrary":{"key":"inferenceGatewayApiKey","value":"<the key>"}}))+//+// (its custom-3p:keys sweep; protect is the user's DPAPI on Windows, its+// native userDpapiProtect, and Electron's safeStorage, the Keychain, on+// macOS), and opens it again when it reads the profile.+// It sends the gateway the key as it was, so the value magpie wrote no+// longer reads as magpie's key in the file while Desktop still runs on it:+// magpie said the key "was changed", Reconnect wrote it in the clear and+// Desktop sealed it again at its next start (a Windows user on Discord).+const (+ desktopSealed = "__sealed__:v1:"+ desktopSealedWith = "anthropic.claude.crossProfileSecret.v1:"+)++// errDesktopSealed: Desktop sealed a value with a keystore magpie can't+// open here.+var errDesktopSealed = errors.New("sealed by Claude Desktop")++// desktopOpen is the value v Desktop keeps at key k of a configLibrary+// profile, as Desktop reads it: v itself, or what a sealed v opens to.+// known is false for a sealed value magpie can't open (another system's+// keystore, another user's, or not one of Desktop's): what it holds is+// unknown, which is not the same as changed.+func desktopOpen(k, v string) (open string, known bool) {+ t := strings.TrimLeft(v, " \t\r\n")+ if !strings.HasPrefix(t, desktopSealed) {+ return v, true+ }+ b, err := base64.StdEncoding.DecodeString(strings.TrimSpace(t[len(desktopSealed):]))+ if err != nil {+ return "", false+ }+ plain, err := desktopUnprotect(b)+ if err != nil {+ return "", false+ }+ s, ok := strings.CutPrefix(string(plain), desktopSealedWith)+ if !ok {+ return "", false+ }+ var m struct {+ ConfigLibrary struct {+ Key string `json:"key"`+ Value *string `json:"value"`+ } `json:"configLibrary"`+ }+ // Desktop opens a value only for the key it was sealed for+ if json.Unmarshal([]byte(s), &m) != nil || m.ConfigLibrary.Key != k || m.ConfigLibrary.Value == nil {+ return "", false+ }+ return *m.ConfigLibrary.Value, true+}diff --git a/internal/agent/desktopseal_other.go b/internal/agent/desktopseal_other.gonew file mode 100644index 000000000..6a3e47b33--- /dev/null+++ b/internal/agent/desktopseal_other.go@@ -0,0 +1,7 @@+//go:build !windows++package agent++// desktopUnprotect: outside Windows magpie opens nothing Claude Desktop+// sealed; what it holds stays unknown.+func desktopUnprotect([]byte) ([]byte, error) { return nil, errDesktopSealed }diff --git a/internal/agent/desktopseal_test.go b/internal/agent/desktopseal_test.gonew file mode 100644index 000000000..3b1173390--- /dev/null+++ b/internal/agent/desktopseal_test.go@@ -0,0 +1,97 @@+package agent++import (+ "encoding/base64"+ "os"+ "path/filepath"+ "strings"+ "testing"++ "github.com/yetone/magpie/internal/edit"+ "github.com/yetone/magpie/internal/gateway"+)++// a value Claude Desktop sealed with a keystore magpie can't open (another+// user's DPAPI on Windows, the Keychain's "Claude Safe Storage" on macOS)+var desktopForeignSeal = desktopSealed + base64.StdEncoding.EncodeToString([]byte("not this user's keystore"))++// Claude Desktop 4.4212 seals inferenceGatewayApiKey in magpie's profile at+// its next start. Desktop still runs on magpie: the check doesn't say the+// key was changed, and Sync and Reconnect leave nothing to undo.+func TestClaudeDesktopSealedKeyIsNotChanged(t *testing.T) {+ home, p := desktopSandbox(t)+ os.MkdirAll(p.dir, 0o755)+ a := claudeDesktop(home)+ if err := a.Field("provider").Set("magpie"); err != nil {+ t.Fatal(err)+ }+ if err := edit.SetJSON(p.prof, edit.KV{Path: "inferenceGatewayApiKey", Value: " " + desktopForeignSeal}); err != nil {+ t.Fatal(err)+ }+ if c := a.Check(); c != "" {+ t.Errorf("check with the key sealed: %s", c)+ }+ before, _ := os.ReadFile(p.prof)+ if err := a.Sync(); err != nil {+ t.Fatal(err)+ }+ if b, _ := os.ReadFile(p.prof); string(b) != string(before) {+ t.Errorf("sync rewrote the profile:\n%s", b)+ }++ // a key in the clear that isn't magpie's is still a change+ edit.SetJSON(p.prof, edit.KV{Path: "inferenceGatewayApiKey", Value: "sk-someone-elses"})+ if c := a.Check(); !strings.Contains(c, "inferenceGatewayApiKey") || !strings.Contains(c, "was changed") {+ t.Errorf("check with another key: %q", c)+ }+ // and so is one gone+ edit.DelJSON(p.prof, "inferenceGatewayApiKey")+ if c := a.Check(); !strings.Contains(c, "is gone") {+ t.Errorf("check with no key: %q", c)+ }+ // and an address elsewhere, with the key sealed+ edit.SetJSON(p.prof, edit.KV{Path: "inferenceGatewayApiKey", Value: desktopForeignSeal},+ edit.KV{Path: "inferenceGatewayBaseUrl", Value: "http://elsewhere:1"})+ if c := a.Check(); !strings.Contains(c, "elsewhere") {+ t.Errorf("check with another address: %q", c)+ }+}++// An imported profile for magpie's gateway Desktop applies, its key+// sealed: on magpie, and Sync doesn't write a key over Desktop's.+func TestClaudeDesktopImportedSealedKeyStays(t *testing.T) {+ const imported = "3f6c2a8e-9b1d-4e57-a0c4-7d2e5f81b9a6"+ home, p := desktopSandbox(t)+ os.MkdirAll(p.dir, 0o755)+ a := claudeDesktop(home)+ if err := a.Field("provider").Set("magpie"); err != nil {+ t.Fatal(err)+ }+ f := filepath.Join(p.library, imported+".json")+ prof := `{"inferenceProvider":"gateway","inferenceGatewayBaseUrl":"` + gateway.URL() ++ `","inferenceGatewayApiKey":"` + desktopForeignSeal + `","inferenceGatewayAuthScheme":"bearer"}`+ desktopWrite(t, f, prof)+ desktopWrite(t, p.meta, `{"appliedId":"`+imported+`","entries":[{"id":"`+desktopProfileID+`","name":"magpie"},{"id":"`+imported+`","name":"magpie"}]}`)+ if c := a.Check(); c != "" {+ t.Errorf("check: %s", c)+ }+ if err := a.Sync(); err != nil {+ t.Fatal(err)+ }+ if b, _ := os.ReadFile(f); string(b) != prof {+ t.Errorf("sync wrote the imported profile:\n%s", b)+ }+}++func TestDesktopOpenNotSealed(t *testing.T) {+ for _, v := range []string{"", "magpie-claude-desktop", "__sealed__:v2:abc", "x__sealed__:v1:"} {+ if got, known := desktopOpen("inferenceGatewayApiKey", v); !known || got != v {+ t.Errorf("%q: %q %v", v, got, known)+ }+ }+ for _, v := range []string{desktopSealed, desktopSealed + "%%%", desktopForeignSeal} {+ if got, known := desktopOpen("inferenceGatewayApiKey", v); known || got != "" {+ t.Errorf("%q: %q %v, want unknown", v, got, known)+ }+ }+}diff --git a/internal/agent/desktopseal_windows.go b/internal/agent/desktopseal_windows.gonew file mode 100644index 000000000..54cfc3b0b--- /dev/null+++ b/internal/agent/desktopseal_windows.go@@ -0,0 +1,29 @@+package agent++import (+ "unsafe"++ "golang.org/x/sys/windows"+)++// desktopEntropy is the entropy Claude Desktop's native userDpapiProtect+// (claude-native's user_dpapi) gives CryptProtectData: its secret's+// purpose, the one string beside CryptProtectData in the binary (4.4212).+const desktopEntropy = "anthropic.claude.crossProfileSecret.v1"++// desktopUnprotect opens what Claude Desktop sealed with the user's DPAPI+// (userDpapiProtect), never prompting.+func desktopUnprotect(b []byte) ([]byte, error) {+ if len(b) == 0 {+ return nil, errDesktopSealed+ }+ in := windows.DataBlob{Size: uint32(len(b)), Data: &b[0]}+ e := []byte(desktopEntropy)+ entropy := windows.DataBlob{Size: uint32(len(e)), Data: &e[0]}+ var out windows.DataBlob+ if err := windows.CryptUnprotectData(&in, nil, &entropy, 0, nil, windows.CRYPTPROTECT_UI_FORBIDDEN, &out); err != nil {+ return nil, err+ }+ defer windows.LocalFree(windows.Handle(unsafe.Pointer(out.Data)))+ return append([]byte(nil), unsafe.Slice(out.Data, out.Size)...), nil+}diff --git a/internal/agent/desktopseal_windows_test.go b/internal/agent/desktopseal_windows_test.gonew file mode 100644index 000000000..efc3d5ec2--- /dev/null+++ b/internal/agent/desktopseal_windows_test.go@@ -0,0 +1,63 @@+package agent++import (+ "encoding/base64"+ "encoding/json"+ "os"+ "strings"+ "testing"+ "unsafe"++ "golang.org/x/sys/windows"++ "github.com/yetone/magpie/internal/edit"+)++// desktopSealHere seals v at key k as Claude Desktop does on Windows: the+// user's DPAPI, with its entropy, over its prefix and+// {"configLibrary":{key,value}}.+func desktopSealHere(t *testing.T, k, v string) string {+ t.Helper()+ j, _ := json.Marshal(map[string]any{"configLibrary": map[string]string{"key": k, "value": v}})+ b := []byte(desktopSealedWith + string(j))+ in := windows.DataBlob{Size: uint32(len(b)), Data: &b[0]}+ e := []byte(desktopEntropy)+ entropy := windows.DataBlob{Size: uint32(len(e)), Data: &e[0]}+ var out windows.DataBlob+ if err := windows.CryptProtectData(&in, nil, &entropy, 0, nil, windows.CRYPTPROTECT_UI_FORBIDDEN, &out); err != nil {+ t.Fatal(err)+ }+ defer windows.LocalFree(windows.Handle(unsafe.Pointer(out.Data)))+ return desktopSealed + base64.StdEncoding.EncodeToString(unsafe.Slice(out.Data, out.Size))+}++func TestDesktopOpensWhatDesktopSealed(t *testing.T) {+ k := "inferenceGatewayApiKey"+ if got, known := desktopOpen(k, desktopSealHere(t, k, "magpie-x-claude-desktop")); !known || got != "magpie-x-claude-desktop" {+ t.Errorf("opened %q %v", got, known)+ }+ // sealed for another key: Desktop wouldn't open it there either+ if got, known := desktopOpen(k, desktopSealHere(t, "anthropicApiKey", "sk")); known {+ t.Errorf("another key's seal opened to %q", got)+ }+}++// On Windows magpie opens the key Desktop sealed: magpie's own is on+// magpie, another one sealed is a change.+func TestClaudeDesktopSealedKeyOpened(t *testing.T) {+ home, p := desktopSandbox(t)+ os.MkdirAll(p.dir, 0o755)+ a := claudeDesktop(home)+ if err := a.Field("provider").Set("magpie"); err != nil {+ t.Fatal(err)+ }+ k := "inferenceGatewayApiKey"+ edit.SetJSON(p.prof, edit.KV{Path: k, Value: desktopSealHere(t, k, agentKey("claude-desktop"))})+ if c := a.Check(); c != "" {+ t.Errorf("check with magpie's key sealed: %s", c)+ }+ edit.SetJSON(p.prof, edit.KV{Path: k, Value: desktopSealHere(t, k, "sk-someone-elses")})+ if c := a.Check(); !strings.Contains(c, "was changed") {+ t.Errorf("check with another key sealed: %q", c)+ }+}