06-reference/research

cortex code connection profile plugin set

2026-11-05·research-brief·source: deep-research·by Ray Data Co (deep-research synthesis)
snowflake-cocogoverned-rolloutmanaged-settingsplugin-governancephdata

A CoCo connection profile delivers plugins but does not govern them. The governable seam is permissions in a root-owned managed-settings.json, CoCo's managed schema has forked from Claude Code's, and strictKnownMarketplaces is not in it.

The question

"How is a Cortex Code connection-profile plugin set defined and delivered (connections.toml key, managed-settings file, or account object), can an end user override it, and does CoCo honor Claude Code managed-settings keys such as strictKnownMarketplaces and plugin userConfig sensitive fields?"

This merges the first two open follow-ups from [[2026-09-14-brigade-snowflake-connection-profile-governed-rollout]]. It is a governance question, not a packaging one: if RDCO/phData ships a governed plugin set to a client's analysts through CoCo, the value collapses the moment an analyst can swap it out.

Label convention used throughout. Every claim below is tagged [CoCo-verified] (read today at a Snowflake docs page), [CC-only] (verified in the local Claude Code install, upstream behavior that is not established for CoCo), or [unresolved]. CoCo is a fork. Silence in Snowflake's docs is not confirmation that upstream behavior carries over, and this brief found two-way divergence that proves the point.

What we already know (from the vault)

What the web says

All four CoCo pages below were read on 2026-11-05. None carries a "last updated" stamp, a Preview label, or a GA label; the only date text is a 2026 copyright footer. Two of them (/settings and /managed-settings) were search-level or unseen in the parent briefs, and /managed-settings is where the governance answer actually lives.

Convergences and contradictions

The five resolution points

  1. Delivery mechanism — partially resolved, and it is not an account object. [CoCo-verified] The plugin set is declared by the active Snowflake connection profile, it is discovery source 2 of 7, and profile-shipped plugins surface with origin profile in cortex plugin list. [CoCo-verified] Connections themselves live in ~/.snowflake/connections.toml or the shared ~/.snowflake/config.toml, and an administrator can pin a root-owned connections file via managed files.connectionsFile (documented example /etc/cortex/connections.toml). [CoCo-verified] Nothing in CoCo's docs describes a Snowflake account-level object for plugin sets, so the "account object" branch of the question is answered no. [unresolved] The exact key that declares the plugin list inside a profile. All three relevant pages are silent; the docs do not state this, and it would need a test against a real CoCo deployment. The practically important half is resolved regardless: whichever key it is, files.connectionsFile makes the file itself administrator-owned and root-writable-only.
  2. User override — resolved, and the answer is yes, three ways. [CoCo-verified] (a) --plugin-dir ranks above the connection profile under first-wins dedupe-by-name, so cortex --plugin-dir <dir> carrying a same-named plugin shadows the administrator's. (b) defaults.profileName is in the soft half of managed settings: "Users can override this with -c or by changing their own settings," so a user can leave the governed profile entirely. (c) The working-directory sources .cortex/plugins/ and .claude/plugins/ are a further injection path from any repo an analyst clones. [unresolved] Whether cortex plugin disable/uninstall act on a profile-origin plugin; the page documents those commands only for "managed" plugins. The docs do not state this; it needs a test against a real CoCo deployment. [CoCo-verified] The genuine control that is non-overridable is permissions under settings.* with plugin(*) / plugin(bundled:*) / skill(profile:*) patterns. Governance in CoCo is an allowlist on what may run, not a pin on what gets discovered.
  3. strictKnownMarketplaces — resolved: no. [CoCo-verified] The string does not appear on CoCo's plugins, settings, or managed-settings pages, and CoCo's published enforcement schema is a different, sectioned shape with no marketplace-allowlist concept at all. [CC-only] The key is real upstream, is managed-settings-only, has an alias allowedMarketplaces, has a counterpart blockedMarketplaces, and has a companion disableSideloadFlags whose entire purpose is to close the --plugin-dir bypass. That companion is exactly what CoCo appears to be missing, which is why point 2(a) is open. Treat all six upstream keys as unavailable in CoCo until Snowflake documents otherwise.
  4. Plugin userConfig sensitive fields — unresolved for CoCo. [CoCo-verified] Neither userConfig nor sensitive appears on any CoCo page read today. [CC-only] Upstream routes userConfig options marked sensitive to the macOS Keychain and falls back to plaintext ~/.claude/.credentials.json with an explicit plaintext warning when the Keychain is unwritable or the platform is not macOS. The Sept 14 brief verified CoCo's MCP credential path (keychain, ${VAR} expansion, graceful no-disk degradation headless), but userConfig is a plugin-manifest feature on a different code path and cannot be inferred from it. The docs do not state this; it would need a test against a real CoCo deployment. Until then, do not ship a userConfig sensitive: true field in a client-bound plugin.
  5. CoCo-specific divergences an administrator would be surprised by — resolved, six of them. [CoCo-verified] (a) The managed file path is Cortex, not ClaudeCode: an MDM profile written against /Library/Application Support/ClaudeCode/managed-settings.json or /etc/claude-code/managed-settings.json lands nowhere for CoCo. (b) The schema is sectioned (permissions/settings/defaults/files/...), not Claude Code's flat key set, so key-level reuse fails even where intent matches. (c) Managed settings are split into non-overridable settings.* and user-overridable defaults.* — an admin who puts a control in defaults has shipped a suggestion, not a policy, and nothing in the key name warns them. (d) Connection profile is highest priority for hooks and second for plugins, an inversion that makes "profile-delivered" mean two different strengths depending on surface. (e) CoCo reads .claude/plugins/ and .claude/settings.json from the working directory, so Claude-Code-named artifacts in a client repo are live inputs to CoCo. (f) "Profile" is overloaded: connection profile (plugins, hooks, origin profile) versus settings profile (settingsOverrides, precedence position 2). These are not the same object and the docs do not cross-reference them.

Synthesis for RDCO

The governed-rollout pitch has to change shape, and the change is specific rather than cosmetic. "Ship the governed plugin set via a Snowflake connection profile" reads like a Snowflake-side control and is not one. Profile delivery is discovery rank 2 of 7 under first-wins dedupe, sitting directly beneath a CLI flag that any analyst can pass, with no documented equivalent of upstream's disableSideloadFlags to close that bypass. An analyst who prefers their own version of a Brigade skill gets it by naming a directory and adding one flag. If we sell "consistent baseline" on the strength of the profile alone, the first curious analyst falsifies the claim, and they falsify it inside the client's own environment rather than in ours.

What replaces it is narrower but real, and it relocates the sale. The enforceable seam is permissions under settings.* in a root-owned managed-settings.json at /etc/cortex/managed-settings.json or the macOS and Windows equivalents, optionally paired with files.connectionsFile so the connections file itself is administrator-owned. That is an allowlist on what may run, expressed in plugin(...) and skill(profile:*) patterns, plus a pinned connections file. Two consequences follow. First, the deliverable is an endpoint-management artifact, not a Snowflake artifact: it ships through the client's MDM and needs root on analyst machines, so the counterparty is desktop/IT, not ACCOUNTADMIN. Every prior estimate that treated this as a Snowflake-account task is scoped against the wrong buyer and the wrong approval chain. Second, the split between settings.* and defaults.* has to be a named line item in any configuration we hand over, because putting a control in the wrong half silently downgrades it to a default a user can edit. That is a lint check we can write and a differentiator we can demonstrate.

The forked-schema finding is the piece with the longest reach, and it generalizes past this question. CoCo carries a marketplace-governance gap relative to upstream while also carrying at least one control upstream does not have, so neither schema is a superset of the other. Any sentence of the form "CoCo is Claude Code underneath, so the enterprise policy keys carry over" is now disproven by example in both directions. Practically: no Claude Code enterprise-policy recommendation reaches a client through us without being re-derived against CoCo's own schema page, and strictKnownMarketplaces, blockedMarketplaces, extraKnownMarketplaces, strictPluginOnlyCustomization and disableSideloadFlags are all off the table for CoCo deployments today. The same caution applies to the credential path: the MCP side is verified for CoCo, the plugin-manifest userConfig side is not, and the upstream fallback to plaintext ~/.claude/.credentials.json is exactly the failure mode our own no-secrets-on-disk rule exists to prevent ([[mcp-server-setup]]).

Finally, this strengthens rather than complicates the P3 recommendation already on the books. [[2026-09-13-cortex-code-client-deployable-surface-p3-p4]] landed on the CoCo CLI inside an SPCS container using skills. That path makes the entire override problem moot, because the analyst never holds the CLI process and therefore never holds --plugin-dir, -c, or a working directory we did not build. The override hole is an argument for the container, not against it. Where a client insists on analyst laptops, we should quote the MDM-delivered managed-settings.json as the governance control and say plainly that profile delivery is convenience, not enforcement.

Why this is in the vault

It closes the governance-control cell for deployment profile P3 in [[2026-07-07-hex-deployment-matrix-v2]] with a mechanism rather than an absence, and it retires the "connection profile = governed distribution" wording from [[2026-07-05-brigade-skills-snowflake-cortex-code]] before that phrasing reaches a client admin or a phData/Snowflake partner conversation. It also reassigns the counterparty for the governance deliverable from ACCOUNTADMIN to client endpoint management, which changes who has to approve a P3 rollout.

Live-deployment test plan

These are not research questions. Each is undocumented and resolvable only against a real CoCo install, so they belong here rather than in the follow-up queue.

  1. Find the profile plugin key. On a machine with CoCo CLI, add a trivial plugin to a connection profile by trial across candidate keys in ~/.snowflake/connections.toml (plugins, plugin_dirs, cortex_plugins), then run cortex plugin list and look for origin profile. Record the key that works.
  2. Confirm the --plugin-dir shadow. With a profile-delivered plugin named X active, launch cortex --plugin-dir <dir-containing-a-different-X> and check which one cortex plugin list reports and which one actually loads. This is the single most load-bearing unverified claim in the brief.
  3. Test user removal of a profile plugin. Run cortex plugin disable <X> and cortex plugin uninstall <X> against a profile-origin plugin and record whether either succeeds.
  4. Test whether any upstream marketplace key is silently honored. Place strictKnownMarketplaces and disableSideloadFlags into /etc/cortex/managed-settings.json, restart, and check both for enforcement and for a schema-rejection warning. An undocumented-but-honored key would be a materially better answer than the current no.
  5. Test userConfig sensitive handling. Ship a plugin whose manifest declares a userConfig option with sensitive: true, install it in CoCo, and record whether CoCo prompts for it, where it stores the value, and whether any plaintext file appears. Run once on macOS and once in a keychain-less Linux container.
  6. Verify the settings.* versus defaults.* split empirically. Place the same control in each half, then attempt a user override from ~/.snowflake/cortex/settings.json and from a -c flag. This is the lint rule we would sell; it should be measured, not quoted.

Open follow-ups

Related

Sources

Vault

Web, fetched 2026-11-05 (all three Snowflake pages undated, no Preview/GA label)

Web, search-level 2026-11-05

Local install, primary evidence for all [CC-only] claims

Research caps

QMD 2 of 5 queries. WebSearch 2 of 3. WebFetch 3 of 3 sources, all Snowflake docs, no paywalls encountered and no fetch failures. Parent briefs were read via a subagent extract rather than into this context, per the >5KB artifact rule.