@@ -11,3 +11,7 @@ git_sim.egg-info/
 
 # Claude Code local (per-machine) settings
 .claude/settings.local.json
+
+# VS Code extension build output
+vscode/*.vsix
+vscode/LICENSE.txt
@@ -45,6 +45,7 @@ Git-Sim is Free and Open-Source Software (FOSS). Your support will help me work
 - Animation only: Add custom branded intro/outro sequences if desired
 - Animation only: Speed up or slow down animation speed as desired
 - NEW: [MCP server and Claude Code hook](docs/mcp.md) so AI coding agents (Claude Code, Cursor, etc.) run deterministic pre-flight checks — facts, a text commit graph and a simulation image — before executing destructive git commands in your repo. Included in the default install.
+- NEW: `git-sim preflight <command>` runs that same check from the terminal, and the [VS Code extension](docs/vscode.md) puts simulations and pre-flight checks in an editor tab.
 
 ## Quickstart
 Note: If you prefer to install git-sim with Docker, skip steps (1) and (2) here and jump to the [Docker installation](#docker-installation) section below, then come back here to step (3).
@@ -101,7 +102,7 @@ Or if you want to do it all in a single command:
 $ git-dummy --no-subdir --branches=3 --commits=10 && git-sim [global options] <subcommand> [subcommand options]
 ```
 
-5) Simulated output will be created as an interactive `.html` page (or a `.jpg` / `.png` image with `--img-format`). Output files are named using the subcommand executed combined with a timestamp, and by default are stored in a subdirectory called `git-sim_media/`. The location of this subdirectory is customizable using the command line flag `--media-dir=path/to/output`. Note that when the `--animate` global flag is used, render times will be much longer and a `.mp4` video output file will be produced.
+5) Simulated output will be created as an interactive `.html` page (or a `.jpg` / `.png` image with `--img-format`). Output files are named using the subcommand executed combined with a timestamp, and are stored in a `git-sim_media/` folder with a subfolder per repository. By default that folder lives in your user cache area, outside any repository (`%LOCALAPPDATA%\git-sim_media` on Windows, `~/Library/Caches/git-sim_media` on macOS, `~/.cache/git-sim_media` on Linux); `git-sim media-dir` prints it. Move it with `--media-dir=path/to/output` or the `git_sim_media_dir` environment variable (`--media-dir .` puts it in the current folder, as older versions did). Note that when the `--animate` global flag is used, render times will be much longer and a `.mp4` video output file will be produced.
 
 6) For convenience, environment variables can be set for any global command-line option available in git-sim. All environment variables start with `git_sim_` followed by the name of the option.
 
@@ -562,7 +563,7 @@ Use light mode (soft off-white background, dark text) instead of the default dar
 $ git-sim --light-mode status
 ```
 
-The default output is a self-contained interactive HTML page, saved under `git-sim_media/` and opened in the git-sim viewer at initialcommit.com. Drag the Before / After slider (or press play) to watch the command happen, hover commits for details, ctrl + wheel to zoom. The graph travels compressed in the link's `#fragment`, which browsers never send to a server, and the link git-sim opens carries nothing else about you or your repository (the command rides in the fragment too), so the server learns nothing about your code. The hosted page notes that git-sim opened it and the name of the local copy. The Share button builds a link meant for posting: that one also puts the command and a short text graph (`git log --oneline`, up to 12 lines) in the query string so the link gets a preview card. `#before`, `#after` or `#step=N` in a link pins the state, and `git_sim_viewer_url` points links at your own copy of the viewer:
+The default output is a self-contained interactive HTML page, saved under `git-sim_media/` in your user cache area (see `git-sim media-dir`) and opened in the git-sim viewer at initialcommit.com. Drag the Before / After slider (or press play) to watch the command happen, hover commits for details, ctrl + wheel to zoom. The graph travels compressed in the link's `#fragment`, which browsers never send to a server, and the link git-sim opens carries nothing else about you or your repository (the command rides in the fragment too), so the server learns nothing about your code. The hosted page notes that git-sim opened it and the name of the local copy. The Share button builds a link meant for posting: that one also puts the command and a short text graph (`git log --oneline`, up to 12 lines) in the query string so the link gets a preview card. `#before`, `#after` or `#step=N` in a link pins the state, and `git_sim_viewer_url` points links at your own copy of the viewer:
 
 ```console
 $ git-sim rebase -i main --todo todo.txt
 
@@ -150,7 +150,20 @@ its own format:
 | Cursor | `~/.cursor/hooks.json` → `hooks.beforeShellExecution` | `~/.cursor/mcp.json` |
 | GitHub Copilot CLI | `~/.copilot/hooks/git-sim.json` → `hooks.preToolUse` | `~/.copilot/mcp-config.json` |
 | Gemini CLI | `~/.gemini/settings.json` → `hooks.BeforeTool` (matcher `run_shell_command`) | same file → `mcpServers` |
-| VS Code (Copilot) | — (no shell hook) | user `mcp.json` → `servers` |
+| VS Code (Copilot) | shares Copilot CLI's `~/.copilot/hooks/git-sim.json` (VS Code's agent hooks read it) | user `mcp.json` → `servers` |
+
+Under VS Code the hook behaves a little differently: it renders the
+interactive page instead of an image, does not open a viewer window, and leaves
+a note in `git-sim_media/inbox/` that the git-sim extension picks up to open the
+page in an editor tab. It also answers for git commands that rate below the
+threshold with an "allow" carrying a one-line SAFE or CAUTION note, so a
+verdict shows on every git command (`GIT_SIM_HOOK_REPORT_SAFE=0` turns that
+off; `=1` turns it on for other agents).
+
+The hook and MCP commands are written as absolute paths. Where the console
+scripts are missing (an editable install made before they existed) the
+interpreter runs the module instead (`python -m git_sim.claude_hook`), so a
+bare name that might not be on the agent's PATH is never written.
 
 Options: `--agent claude --agent cursor` to pick agents, `--all` for every
 supported one, `--scope project` to write into the current repo instead of
 
@@ -0,0 +1,71 @@
+# git-sim for VS Code
+
+The extension in [`vscode/`](../vscode) puts git-sim in the editor: simulate a
+Git command in an editor tab, or pre-flight it first and see what it would do,
+lose, and how to undo it. It is a thin client over the `git-sim` command line,
+so it needs no build step and tracks git-sim releases for free.
+
+## Using it
+
+1. Install git-sim: `pipx install git-sim` (or `uv tool install git-sim`).
+2. Install the extension from the Marketplace, or from a `.vsix` (below).
+3. In a repository: `Ctrl+Alt+G`, the beaker button in the Source Control view,
+   or **git-sim: Simulate a Git command...** from the Command Palette. Type the
+   command as you would after `git`, for example `rebase main`.
+
+**Pre-flight** is the safety half: **git-sim: Pre-flight a Git command...** shows
+the risk level, the commits that would become unreachable, the files that would
+be lost, how to undo it and a text commit graph, with a button to simulate it.
+Select a command in a file or a terminal and the context menu offers both.
+
+Settings live under `git-sim` (executable, extra options, light-mode graphs when
+the editor theme is light, open in the browser instead of a tab, timeout).
+
+## The `preflight` command
+
+The extension calls `git-sim preflight --json`, which is also useful on its own:
+
+```
+$ git-sim preflight reset --hard HEAD~1
+DESTRUCTIVE  git reset --hard HEAD~1
+
+Moves main from 3cb9050 to 3808596 (hard reset).
+
+What happens:
+  1 commit(s) will no longer be reachable from main:
+    3cb9050 commit 3
+...
+```
+
+Git's own options pass straight through; quoting the whole command works too
+(`git-sim preflight "git stash drop"`). `--json` prints the report the MCP
+server returns; `-C <path>` checks another repository. Only analysis runs:
+nothing is rendered and the repository is never modified.
+
+## Building the extension
+
+The extension is plain JavaScript, so there is nothing to compile. To package
+it without Node, run the bundled script (Python 3.10+):
+
+```
+python vscode/build_vsix.py        # -> vscode/git-sim-0.1.0.vsix
+code --install-extension vscode/git-sim-0.1.0.vsix
+```
+
+With Node available, `npx @vscode/vsce package` in `vscode/` produces the same
+file. To try changes live, open `vscode/` in VS Code and press F5.
+
+## How it works
+
+- Simulations: `git-sim --img-format html --output-only-path <command>` in the
+  chosen repository. The self-contained page git-sim writes is shown in a
+  webview with a content-security policy allowing only its inline parts.
+- Pre-flight: `git-sim preflight --json -- <command>`, rendered as a small
+  report page with a Simulate button.
+- The repository is the one holding the active file, else the workspace folder
+  (a quick pick when there are several).
+- `git-sim: Wire git-sim into AI coding agents` runs `git-sim install`, which
+  gives VS Code both halves of the agent story: the pre-flight hook (VS Code's
+  agent hooks read Copilot CLI hook files, so it shares
+  `~/.copilot/hooks/git-sim.json`) and the MCP server in the user `mcp.json`,
+  for Copilot's Agent mode (see [mcp.md](mcp.md)). Restart VS Code afterwards.
@@ -309,11 +309,18 @@ def main(
 app.command()(git_sim.commands.reflog)
 app.command()(git_sim.commands.submodule)
 
-# Agent integration (not git subcommands).
+# Agent integration and the pre-flight check (not git subcommands).
 from git_sim.install import install, uninstall  # noqa: E402
+from git_sim.paths import media_dir  # noqa: E402
+from git_sim.preflight_cli import preflight  # noqa: E402
 
 app.command()(install)
 app.command()(uninstall)
+app.command()(media_dir)
+# git's own options (--hard, -f, ...) must pass through to the command being checked
+app.command(
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True}
+)(preflight)
 
 
 if __name__ == "__main__":
 
@@ -7,10 +7,11 @@
 rendered git-sim image of the operation.
 
 It speaks the hook dialects of Claude Code, Codex CLI, Cursor, GitHub
-Copilot CLI and Gemini CLI. The agent is taken from ``--agent <name>`` when
-the installer put it in the config, and detected from the payload shape
-otherwise. Agents whose hooks can ask the user (Claude Code, Cursor,
-Copilot) get an "ask" decision; agents whose hooks can only allow or deny
+Copilot CLI, Gemini CLI and VS Code's agent hooks (which read Copilot CLI
+hook files, so the two share one). The agent is taken from ``--agent <name>``
+when the installer put it in the config, and detected from the payload shape
+otherwise. Agents whose hooks can ask the user (Claude Code, Cursor, Copilot,
+VS Code) get an "ask" decision; agents whose hooks can only allow or deny
 (Codex, Gemini) get a deny whose reason carries the facts and tells the
 agent how to proceed once the user has approved.
 
@@ -28,6 +29,17 @@
     GIT_SIM_HOOK_OPEN    "0" to skip auto-opening the rendered image.
     GIT_SIM_HOOK_TEXT    "0" to omit the plain-text commit graph.
     GIT_SIM_HOOK_AGENT   force the agent dialect (same values as --agent).
+    GIT_SIM_HOOK_REPORT_SAFE
+                         "1": also answer for git commands the engine rated
+                         below the threshold, with an "allow" that carries a
+                         one-line "SAFE" (or "CAUTION") note, so the user sees
+                         the level every time. Default "1" inside VS Code,
+                         "0" elsewhere (where it would only add noise).
+
+Inside VS Code (its agent hooks, or Copilot CLI's shared hook file running
+under VS Code) the hook renders the interactive page instead of an image, does
+not pop a viewer window, and leaves a note in git-sim_media/inbox for the
+git-sim extension, which opens the page in an editor tab.
 
 Approval override: a command prefixed with ``GIT_SIM_APPROVE=1`` (or
 ``$env:GIT_SIM_APPROVE=1;`` in PowerShell) is let through without a
@@ -40,6 +52,7 @@
 import re
 import subprocess
 import sys
+import time
 from typing import List, Optional, Tuple
 
 from git_sim.preflight import (
@@ -70,8 +83,18 @@
     "cursor": {"label": "Cursor", "asks": True},
     "copilot": {"label": "GitHub Copilot CLI", "asks": True},
     "gemini": {"label": "Gemini CLI", "asks": False},
+    "vscode": {"label": "VS Code", "asks": True},
 }
-SHELL_TOOLS = {"bash", "powershell", "shell", "run_shell_command", "run_terminal_cmd"}
+SHELL_TOOLS = {
+    "bash",
+    "powershell",
+    "shell",
+    "run_shell_command",
+    "run_terminal_cmd",
+    "runterminalcommand",  # VS Code agent hooks
+    "run_in_terminal",
+}
+VSCODE_TOOLS = {"runterminalcommand", "run_in_terminal"}
 
 
 def extract_git_commands(shell_command: str) -> List[str]:
@@ -136,7 +159,58 @@ def _open_file(path: str) -> None:
         pass
 
 
-def format_reason(reports: List[PreflightReport], image_path: Optional[str]) -> str:
+def in_vscode(agent: Optional[str], hook_input: dict) -> bool:
+    """Whether this hook call comes from VS Code: its own agent dialect, its
+    terminal tool in the payload (the shared Copilot hook file runs there too),
+    or VS Code's process environment around us."""
+    tool = str(hook_input.get("tool_name") or "").lower()
+    return (
+        agent == "vscode" or tool in VSCODE_TOOLS or bool(os.environ.get("VSCODE_PID"))
+    )
+
+
+def post_to_inbox(page_path: str, report: PreflightReport, cwd: str) -> Optional[str]:
+    """Leave a note for the VS Code extension about an interactive page just
+    written, so it can open it in an editor tab. Written to a temporary name
+    and renamed, so a watcher never reads a half-written file."""
+    from git_sim.paths import inbox_dir
+
+    try:
+        inbox = inbox_dir()
+        inbox.mkdir(parents=True, exist_ok=True)
+        stamp = time.time_ns()
+        record = {
+            "page": page_path,
+            "command": report.command,  # already starts with "git"
+            "risk": report.risk.value,
+            "repo": cwd,
+            "time": stamp,
+        }
+        tmp = inbox / f".{os.getpid()}-{stamp}.tmp"
+        final = inbox / f"{stamp}.json"
+        tmp.write_text(json.dumps(record), encoding="utf-8")
+        tmp.replace(final)
+        return str(final)
+    except Exception:
+        return None
+
+
+def safe_note(reports: List[PreflightReport]) -> str:
+    """One line per analysed command that stayed below the threshold."""
+    lines = []
+    for report in reports:
+        line = f"git-sim preflight: {report.risk.value.upper()} — {report.command}"
+        if report.summary:
+            line += f" ({report.summary.rstrip('.')})"
+        lines.append(line)
+    return "\n".join(lines)
+
+
+def format_reason(
+    reports: List[PreflightReport],
+    image_path: Optional[str],
+    page_path: Optional[str] = None,
+) -> str:
     lines = []
     for report in reports:
         lines.append(
@@ -162,6 +236,10 @@ def format_reason(reports: List[PreflightReport], image_path: Optional[str]) ->
         lines.append("")
     if image_path:
         lines.append(f"Simulation image: {image_path}")
+    if page_path:
+        lines.append(
+            f"Interactive simulation: {page_path} (opening in a git-sim tab in VS Code)"
+        )
     return "\n".join(lines).strip()
 
 
@@ -223,6 +301,8 @@ def parse_hook_input(
         return agent, command, cwd
     if event == "BeforeTool" or tool == "run_shell_command":
         return "gemini", command, cwd
+    if tool.lower() in VSCODE_TOOLS:
+        return "vscode", command, cwd
     return "claude", command, cwd
 
 
@@ -249,8 +329,22 @@ def build_output(agent: str, decision: str, reason: str) -> dict:
     """The decision in the agent's own hook output schema."""
     if agent == "cursor":
         return {"permission": decision, "user_message": reason, "agent_message": reason}
-    if agent == "copilot":
-        return {"permissionDecision": decision, "permissionDecisionReason": reason}
+    if agent in ("copilot", "vscode"):
+        # Copilot CLI reads the decision at the top level; VS Code's agent hooks
+        # read Copilot's hook files but take it under hookSpecificOutput. One
+        # answer carries both, so the shared hook file works in either.
+        output = {
+            "permissionDecision": decision,
+            "permissionDecisionReason": reason,
+            "hookSpecificOutput": {
+                "hookEventName": "PreToolUse",
+                "permissionDecision": decision,
+                "permissionDecisionReason": reason,
+            },
+        }
+        if decision == "allow":
+            output["systemMessage"] = reason  # VS Code shows this beside the call
+        return output
     if agent == "gemini":
         output = {"decision": decision, "systemMessage": reason}
         if decision != "allow":
@@ -287,29 +381,46 @@ def run_hook(hook_input: dict, agent: Optional[str] = None) -> Optional[dict]:
     if APPROVAL_OVERRIDE.search(command):
         return None  # the user already approved this exact command
 
+    vscode = in_vscode(agent, hook_input)
     threshold = os.environ.get("GIT_SIM_HOOK_ASK_ON", "caution")
     render_text = os.environ.get("GIT_SIM_HOOK_TEXT", "1") != "0"
-    flagged = []
+    analysed, flagged = [], []
     for git_command in risky_git_commands(command):
         report = analyze(git_command, cwd, render_text=render_text)
-        if report.error is None and _risk_triggers(report.risk, threshold):
+        if report.error is not None:
+            continue
+        analysed.append(report)
+        if _risk_triggers(report.risk, threshold):
             flagged.append(report)
 
     if not flagged:
+        # Below the threshold: silent by default, or an "allow" that still names
+        # the level, so the user sees a verdict on every git command (VS Code).
+        report_safe = os.environ.get("GIT_SIM_HOOK_REPORT_SAFE", "1" if vscode else "0")
+        if analysed and report_safe != "0":
+            return build_output(agent, "allow", safe_note(analysed))
         return None
 
-    image_path = None
+    image_path = page_path = None
     if os.environ.get("GIT_SIM_HOOK_RENDER", "1") != "0":
         from git_sim.simulate import render_simulation
 
-        rendered = render_simulation(flagged[0].command, cwd)
-        image_path = rendered.get("image_path")
-        if image_path and os.environ.get("GIT_SIM_HOOK_OPEN", "1") != "0":
-            _open_file(image_path)
+        if vscode:
+            # The interactive page, opened by the git-sim extension in an editor
+            # tab (via the inbox note) rather than a picture in a viewer window.
+            rendered = render_simulation(flagged[0].command, cwd, img_format="html")
+            page_path = rendered.get("image_path")
+            if page_path:
+                post_to_inbox(page_path, flagged[0], cwd)
+        else:
+            rendered = render_simulation(flagged[0].command, cwd)
+            image_path = rendered.get("image_path")
+            if image_path and os.environ.get("GIT_SIM_HOOK_OPEN", "1") != "0":
+                _open_file(image_path)
 
     mode = os.environ.get("GIT_SIM_HOOK_MODE", "ask").lower()
     decision = _decide(agent, mode)
-    reason = format_reason(flagged, image_path)
+    reason = format_reason(flagged, image_path, page_path)
     if decision == "deny" and mode == "ask":
         reason += _cannot_ask_note(agent)
     return build_output(agent, decision, reason)