Add an editor integration: Zed, JetBrains, Windsurf or Continue.dev

[bkd-dotcom]

What this is

signetry-plugins bundles the editor and agent integrations that put an admission checkpoint
in front of an AI coding agent. Three editor/agent integrations ship today — Claude Code,
Cursor, Codex — plus universal/, the editor-agnostic guard that everything else hangs off
(git hooks, CI steps, any agent with no plugin here).

Missing, and all four are agentic editors people are actually using: Zed, JetBrains
(IntelliJ/PyCharm/GoLand), Windsurf, Continue.dev.

Why this is mostly wiring, not implementation

The hard part is already done and shared. universal/signetry-guard.sh
accepts --stdin-json, so every existing integration is the same three moves:

1. Hook whatever the editor gives you for "before the agent writes / before the tool runs".
2. Pipe the proposed change to the universal guard as JSON on stdin.
3. Turn a non-zero exit into a block the user can see, with the guard's reason attached.

Read universal/signetry-guard.sh first — it's 43 lines and the whole contract is visible in
them. Then codex/ for a small integration and claude-code/ for a richer hook surface.

One detail to copy deliberately: the guard fails open when signetry isn't installed, so a
missing kernel never blocks someone's commit out of nowhere, and SIGNETRY_GUARD_STRICT=1
makes it fail closed. Whichever your integration does by default, say so in the README.

The deliverable

A new directory: <editor>/ with

• the hook/extension wiring for that editor,
• a README.md with the install steps a real user follows (copy-pasteable, and verified by
  you against the actual editor — a documented install path that 404s or fails to resolve is
  worse than none; we've shipped both of those bugs and fixed them),
• whatever manifest that editor requires.

Pick one editor per PR.

Which one, and what's known about each

Editor	Hook surface to look for	Note
Zed	agent/assistant tool hooks; Zed extensions are WASM but a tool wrapper may be enough	Fast-moving API — pin the version you tested in the README.
JetBrains	plugin with a BeforeDocumentSaved/VCS checkin handler, or the AI Assistant integration point	Highest install-base payoff, heaviest scaffolding (Gradle + plugin.xml).
Windsurf	Cascade rules / MCP	Closest in shape to the existing Cursor integration — start there.
Continue.dev	config hooks, MCP	Config-file driven; probably the smallest diff of the four.

If your editor exposes MCP rather than a shell hook, that's a legitimate route — say so in
the README so users know which mechanism is doing the enforcing.

Acceptance criteria

• Blocks a change the policy forbids, and says why in the editor's own UI. A guard that
  fails silently is worse than no guard.
• Allows a change the policy permits, with no friction added to the normal path.
• Pins signetry-core at an exact tag, matching what the other integrations pin
  (core@v0.8.0 as of today).
• README install steps you have actually run, plus the editor version you ran them on.
• A short "what this can't enforce" note if the editor's hook is advisory rather than
  blocking. Be honest about it — an advisory integration is still useful, and a receipt
  shouldn't imply more than the hook can deliver.

Getting started

git clone https://github.com/Signetry/plugins && cd plugins
cat universal/README.md                       # the guard contract
sed -n '1,45p' universal/signetry-guard.sh    # all of it

pip install "signetry-core @ git+https://github.com/Signetry/core@v0.8.0"
signetry init                                 # scaffold .signetry/admission.yaml
universal/signetry-guard.sh --path src/app.py # the call your hook will make

Comment with the editor you're taking. If you're unsure whether an editor exposes enough to
enforce anything, open the question here first — that answer is useful to write down whether
or not the integration gets built.