CocoPlus wraps a Snowflake data project in phases, hooks and a policy engine

Two command surfaces: cortex installs it, a dollar prefix runs it

Installation is Coco's managed plugin installer, and the repository form is the short one:

cortex plugin install Snowflake-Labs/cocoplus
cortex plugin enable cocoplus

The full URL variant runs the same install step:

cortex plugin install https://github.com/Snowflake-Labs/cocoplus

Everything after installation uses a different naming convention. Runtime commands carry a dollar sign prefix: `$pilot on` and `$pilot off` toggle natural-language orchestration, `$forge` starts the goal-driven expert team loop, `$routine` schedules completed flows as Snowflake TASKs, `$migrate v2` moves older CocoPods forward. The prefix appears to be a session command marker rather than a shell prompt, because `$cocoplus console` is itself one command and the odd one out: it carries the plugin name where every other verb carries a subsystem name, and it launches a browser control plane. Two more commands, `$flow view` and `$meter view`, are named differently again, since they redirect into that console instead of printing anything.

No GitHub releases, while the README discusses V2.0.2

The repository publishes no GitHub releases at all, yet the README narrates a specific version: in V2.0.2 queued hook follow-up work moved to durable request envelopes, stable idempotency keys and skill-owned settlements, so replayed queues no longer duplicate meter, trace or flow artifacts. That change is described in prose with no tag, no compare link and no way to pin the commit that introduced it from the release list, because there is no release list. CHANGELOG.md sits at the repository root next to INSTALLATION.md, AGENTS.md and the LICENSE, so the record exists, just not on the releases page where a version would normally be announced. The root also carries `.cortex-plugin/` and `.cortex/` alongside `cocoplus/`, `docs/`, `recipes/`, `scripts/` and `templates/`, and the README says the root plugin implements the current runtime and documentation surface while older project state is preserved through explicit migration skills. The last commit is dated September 30, 2026 and the project homepage is cocoplus.dev.

PreToolUse policies deny first and cannot be unlocked by accident

The runtime policy engine is the part with real teeth. It applies an `allow()`, `deny()` or `instruct()` decision to Snowflake operations before they run, and it ships with protections for production DROP TABLE, production TRUNCATE, DELETE without WHERE and production ALTER TABLE. Local policy as code is written with safe regex or with the documented `match.operations`, `match.schemas` and `match.tables` rules, so a policy can be scoped to specific objects instead of matching everything. The default is the part worth remembering: custom `allow` overrides for the built-in protections are disabled unless they are explicitly configured. A project that wants DROP TABLE on production has to turn that permission on by name rather than inherit it, and `instruct()` exists as a middle outcome between refusing an operation and waving it through. The policy decision log for those outcomes is exposed in the console Safety panel.

Snowflake write proposals wait for $flow settle

Two gates decide whether work counts as finished. Evidence and proposal gates make stage evidence checks opt-in, and they retain Snowflake-write proposals until someone settles them with `$flow settle`, which is a different model from a tool that executes as soon as the model asks. A write can therefore sit proposed while the session moves on. The scheduling path is narrower still: CocoRoutine is described as opt-in Snowflake TASK scheduling for completed, self-contained flows, driven by `$routine`. A TASK is a database-side scheduler entry, so anything scheduled that way outlives the CocoConsole tab and the agent session that created it, and the opt-in applies to the feature rather than to each individual schedule. Upgrading state has the same shape. Older CocoPods move forward with `$migrate v2 --dry-run` first and `$migrate v2` second, so the migration is expected to be inspected before it is applied. The v2 migration also switches queued hook follow-up work to durable request envelopes and stable idempotency keys, with settlements owned by the skill rather than the queue, which is what stops a replayed queue from writing a second copy of a meter, trace or flow artifact.

Rubric enforcement fails open where the policy engine fails closed

Two evaluation systems sit in the same runtime and they resolve unavailability differently. The policy engine answers an operation question, and its built-in answers are denies. Instruction rubric enforcement answers a quality question, and when the evaluator is unavailable it fails open while writing audit evidence, which the README states outright. The switch is `[cocopod].instruction_rubric_enforcement_enabled`, it compiles committed CocoPod instructions into `lifecycle/rubric.json`, and it applies repair, note and silent probability bands after operations and stages. Beside it, `[cocowisdom].autonomous_wisdom_reflection_enabled` schedules read-only reflection every configured number of turns, with a separate promoter enforcing autonomous-authorship, evidence-ledger, probation and adherence-based archival rules. That reflection lifecycle is disabled by default and never grants write tools to the reflector. Read the two together: a bad instruction rubric degrades to no enforcement plus a log entry, while a bad policy decision degrades to a blocked operation.

Governance starts in observe mode and the console only reports

ReviewerLockout and PII governance are described with an observe and enforce rollout, which means the first stage of PII handling is watching rather than blocking. The audit trail around it is the Notification style surface of this plugin: the console Safety panel holds the Policy Decision Log, and logins, config changes and security events are the kinds of events the audit feed is built around. CocoConsole itself is a local, read-only browser control plane covering Flow, Cost, Sessions, Forge intent translation and Fleet Comms visibility. Read-only cuts both ways. It is the reason you can leave it open while an agent session runs, and it is also why the console cannot be used to change a decision: for the instruction rubric enforcement log and the Pattern Adherence Ledger the README says the console exposes both without mutating either system. Any setting you want to change has to be changed as a command or in configuration, not by clicking.

The vocabulary is a wall of nouns, and each one hides a check

The feature list is dense, so it helps to sort the nouns by what they actually do. CocoFlow is the scheduler: tiered planning, pre-dispatch complexity scoring, an execution conflict gate, a CocoPod liveness check, `lifecycle/context.json` written before dispatch, committed run-policy snapshots, stage model floors, explicit human gates, inbox-first stage transitions, dependency-group dispatch, dotted branch topology, named artifacts, divergence at branch points, synthesis passes and `$flow template` reuse. CocoSession is the budget layer, with PROGRESS handoff, predicate context, iteration and cost budgets with reserve landing, an operator kill-switch, canonical terminal statuses and one-shot steering. CocoWisdom is the memory layer, where `do-not-use.md` stays universal and positive topic files load only when routed by stage or asked for with `$wisdom get`, while `$wisdom reject` writes records of what not to use. Then there are the smaller loops: `$stall` for no-progress detection, `$pulse` for ambient observation, `$adversary` for challenge review, `$diary` for work journals, `$meter` for cost and waste, and `$audit verify` for audit integrity. Eight fixed personas sit on top, from `$de` Data Engineer through `$cdo` Chief Data Officer.

Editorial conclusion

CocoPlus fits teams already working inside Snowflake Coco who want phase gates, named specialists and a written trail of decisions across a data project, and who are willing to keep the opt-in switches off until they trust the output. It does not fit a single operator who wants a lighter helper, since the surface is large enough that turning things on becomes the main design decision. Read three things before switching anything on: which PreToolUse policies your own project overrides, because custom allow rules for built-in protections stay disabled unless you configure them; whether rubric evaluation failing open is acceptable for your rollout, since that path records audit evidence instead of blocking; and what the observe to enforce transition changes in the PII and ReviewerLockout governance, since a hook that only reports in observe mode reports nothing at all in enforce mode. Version tracking is the weakest part: the repository publishes no GitHub releases, the README discusses changes in V2.0.2, and CHANGELOG.md is a separate root file. The last commit is dated September 30, 2026.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. Project website
4. README
5. Snowflake-Labs/cocoplus on GitHub