Mneme HQ + VS Code

Three layers, one corpus

VS Code, Claude Code, and Mneme HQ each do one thing. They stack:

The important property: Mneme governs the agent, not the editor. The same hook fires whether Claude Code is launched from the VS Code integrated terminal, an external terminal, or a remote SSH session. VS Code is a host; the governance follows the agent.

What works today, what is coming

Claude Code inside VS Code — full enforcement, zero extra setup. If you are already running Claude Code in the VS Code terminal, the standard installer wires up the PreToolUse hook in .claude/settings.json. Every Edit, Write, and MultiEdit the agent attempts is checked against your decision corpus before it touches the filesystem.

Copilot inside VS Code — governed in CI, not yet at edit time. Copilot's inline suggestions enter the buffer through the editor itself, not as tool calls Mneme can intercept. Until a native Copilot integration lands, the enforcement point for Copilot-generated code is the GitHub Actions gate: mneme check runs against every PR diff and blocks merges that violate recorded decisions. The diff doesn't care which agent wrote it.

Install

If you already have Claude Code installed in VS Code, the steps are the same as the Claude Code integration:

1. Install the package

   pip install mneme

2. Initialise project memory (if you don't have one yet)

   mkdir .mneme
   # Create .mneme/project_memory.json — see examples/project_memory.json for the schema.

3. Run the installer

   Project-scoped (recommended — only affects this project):

   python scripts/install_claude_code.py

   User-scoped (applies to all Claude Code sessions, including those launched from any VS Code window):

   python scripts/install_claude_code.py --user

4. Verify inside VS Code

   Open the project in VS Code, open the integrated terminal, run claude, and ask the agent to edit a file in a way that violates a recorded decision. The hook should block the edit and surface the decision id back to Claude Code — visible directly in the VS Code terminal pane.

VS Code-specific tips

Integrated terminal vs external terminal

There is no difference from Mneme's point of view. The hook reads $PATH and .claude/settings.json from the environment Claude Code is launched in. If mneme-hook is on $PATH in the VS Code integrated terminal (run where mneme-hook to confirm on Windows, which mneme-hook on macOS / Linux), the hook fires.

Remote-SSH and WSL

VS Code's Remote-SSH and WSL workflows put Claude Code inside the remote environment. Install mneme in that same environment — not on the local Windows host — and the hook works identically. The .mneme/project_memory.json file lives in the repository, so it travels with the project regardless of where the agent runs.

Multiple workspaces, one decision corpus

VS Code multi-root workspaces with several repos behave fine: the hook resolves .mneme/project_memory.json from the file being edited, walking up to the nearest ancestor. Each repo can have its own corpus, and Claude Code's edits are checked against the right one regardless of which folder is focused.

Why not a VS Code extension instead?

A VS Code extension would only see what the user types directly into the editor. The interesting volume — the AI-generated edits worth governing — arrives as agent tool calls, not as keystrokes. Intercepting at the agent's PreToolUse layer is both more precise and more general: the same enforcement runs in any editor that hosts the agent, not just VS Code.

For Copilot specifically, that calculus may shift — Copilot's inline suggestions don't expose a tool-call layer the way Claude Code does, and a VS Code extension may be the right surface for that case. That's on the roadmap. Today, CI carries Copilot enforcement; the editor-time hook carries Claude Code.

FAQ