diff --git a/.github/workflows/bump_version.yml b/.github/workflows/bump_version.yml
deleted file mode 100644
index 4c348ae..0000000
--- a/.github/workflows/bump_version.yml
+++ /dev/null
@@ -1,61 +0,0 @@
-# Generated from xtask::workflows::extensions::bump_version within the Zed repository.
-# Rebuild with `cargo xtask workflows`.
-name: extensions::bump_version
-on:
-  pull_request:
-    types:
-    - labeled
-  push:
-    branches:
-    - main
-    paths-ignore:
-    - .github/**
-  workflow_dispatch: {}
-jobs:
-  determine_bump_type:
-    if: (github.repository_owner == 'zed-industries' || github.repository_owner == 'zed-extensions')
-    runs-on: namespace-profile-2x4-ubuntu-2404
-    permissions: {}
-    steps:
-    - id: get-bump-type
-      name: extensions::bump_version::get_bump_type
-      run: |
-        if [ "$HAS_MAJOR_LABEL" = "true" ]; then
-            bump_type="major"
-        elif [ "$HAS_MINOR_LABEL" = "true" ]; then
-            bump_type="minor"
-        else
-            bump_type="patch"
-        fi
-        echo "bump_type=$bump_type" >> $GITHUB_OUTPUT
-      env:
-        HAS_MAJOR_LABEL: |-
-          ${{ (github.event.action == 'labeled' && github.event.label.name == 'major') ||
-          (github.event.action == 'synchronize' && contains(github.event.pull_request.labels.*.name, 'major')) }}
-        HAS_MINOR_LABEL: |-
-          ${{ (github.event.action == 'labeled' && github.event.label.name == 'minor') ||
-          (github.event.action == 'synchronize' && contains(github.event.pull_request.labels.*.name, 'minor')) }}
-    outputs:
-      bump_type: ${{ steps.get-bump-type.outputs.bump_type }}
-  call_bump_version:
-    needs:
-    - determine_bump_type
-    if: github.event.action != 'labeled' || needs.determine_bump_type.outputs.bump_type != 'patch'
-    permissions:
-      actions: write
-      contents: write
-      issues: write
-      pull-requests: write
-    uses: zed-industries/zed/.github/workflows/extension_bump.yml@3f5705b98542f597d5ffe4d984636c7e0c68fa11
-    secrets:
-      app-id: ${{ secrets.ZED_ZIPPY_APP_ID }}
-      app-secret: ${{ secrets.ZED_ZIPPY_APP_PRIVATE_KEY }}
-    with:
-      bump-type: ${{ needs.determine_bump_type.outputs.bump_type }}
-      force-bump: ${{ github.event_name != 'push' }}
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.ref_name == 'main' && github.sha || 'anysha' }}labels
-  cancel-in-progress: true
-defaults:
-  run:
-    shell: bash -euxo pipefail {0}
diff --git a/.gitignore b/.gitignore
index 4c7bad8..4400a6f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,8 +3,15 @@
 #
 
 *.wasm
+# Zed's development builds clone declared grammars into `grammars/<id>`.
 /grammars
 
+#
+# Node (grammar tooling)
+#
+
+node_modules/
+
 #
 # Rust
 #
diff --git a/BACKLOG.md b/BACKLOG.md
new file mode 100644
index 0000000..28f617a
--- /dev/null
+++ b/BACKLOG.md
@@ -0,0 +1,536 @@
+# C# Web Development Backlog
+
+## Product direction
+
+Make this the integrated C# web-development extension for Zed. It owns C#,
+Razor, .NET project files, and the everyday .NET workflow; existing Zed
+extensions continue to own HTML, CSS, JavaScript, TypeScript, and debugging.
+
+## Decision 0 — Delivery target (DECIDED: fork)
+
+This work ships as a **fork** of `zed-extensions/csharp`, published as a
+distinct extension: id `csharp-plus`, name "C# Plus", crate `zed_csharp_plus`,
+forked at upstream commit `88597e1` (v1.2.2). The alternatives — upstreaming
+into `zed-extensions/csharp`, or shipping a Razor-only extension alongside it —
+were considered and rejected.
+
+**Why the fork wins.** The product goal is one integrated extension owning C#,
+Razor, project files, and the .NET workflow. A Razor-only extension cannot
+deliver that: from Milestone 3 onward it would have to launch its own
+`Microsoft.CodeAnalysis.LanguageServer`, giving two Roslyn processes over one
+solution — double project load, double memory, two divergent views of the same
+compilation. Upstreaming avoids that but puts every step behind review latency
+this project does not control, on a roadmap whose feasibility (G0) is not yet
+established; a maintainer who declines Razor scope at M1, or a proxy binary at
+M4, invalidates the plan retroactively. The fork keeps the integrated product
+*and* full control of sequencing, and it inherits working OmniSharp, csharp-ls,
+NuGet-download and MSBuild code rather than reimplementing it.
+
+**The cost, stated plainly.** C# Plus is a superset of the upstream extension,
+not a companion to it. It registers `.cs`, `.csproj`, `.slnx` and MSBuild files,
+so installing both produces duplicate language ownership. Users must uninstall
+"C#" and install "C# Plus" — a one-time, documented migration (see M1.4), not a
+silent conflict, which keeps faith with the decision below that this project
+does not modify a user's installed extensions. The fork also inherits
+maintenance of the OmniSharp, `csharp-ls` and NuGet code paths, and takes on a
+merge burden against upstream. Both are managed by D0.1 rather than wished away.
+
+- [x] **D0.1 — Establish fork hygiene before M1 starts** *(done 2026-09-05)*
+  - `upstream` remote points at `zed-extensions/csharp`; `origin` points at the
+    fork. (Remote rename done; `origin` is added once the GitHub fork exists.)
+  - **Upstream sync policy:** fetch and merge `upstream/main` at the start of
+    every milestone, and before any release. Record the merged upstream commit
+    in the changelog. Divergence is cheapest to resolve while small; the
+    files most likely to conflict are `languages/csharp/*.scm`,
+    `src/language_servers/roslyn.rs`, and `extension.toml`.
+  - **Attribution:** LICENSE retained unmodified; upstream authors retained in
+    `extension.toml`; provenance and fork commit recorded in README. Apache-2.0
+    requires the notices be preserved and modifications be marked — done, and
+    it must stay done through every merge.
+  - **CI is currently dead in the fork.** `.github/workflows/bump_version.yml`
+    is gated on `repository_owner == 'zed-industries' || 'zed-extensions'`, so
+    it will never run under the fork's owner. Either adopt the gate to the fork
+    owner or replace it with a manual version-bump convention. Decide before
+    M1.0 adds the first real CI job, so there is one workflow story rather than
+    two. *(DECIDED: replaced with the manual convention — `scripts/bump-version.sh`
+    + `docs/versioning.md`; the workflow was removed. One workflow story:
+    `ci.yml`.)*
+  - **Registry:** publishing requires a PR to `zed-industries/extensions`
+    adding `csharp-plus` as a new entry. Verify the id is free before M1.5.
+    *(Verified free 2026-09-05 — registry then contained `csharp` and
+    `csharp-snippets` only.)*
+  - Acceptance: a clean `git merge upstream/main` runs green, the licence and
+    attribution obligations are satisfied, and the version-bump story is one
+    documented mechanism.
+
+## Decisions already made
+
+- Support both ASP.NET Core MVC/Razor Pages (`.cshtml`) and Blazor (`.razor`).
+- Deliver in small releases: Razor editing, workflow improvements, experimental
+  Razor semantics, then stable semantics.
+- Use Roslyn as the only supported semantic backend for Razor. OmniSharp and
+  `csharp-ls` remain C#-only alternatives.
+- Guarantee .NET 8 LTS and newer. Legacy ASP.NET/.NET Framework projects may
+  receive syntax support but are not promised project-aware Razor semantics.
+- Syntax editing is on by default. Razor semantics remain opt-in until stable.
+  See M0.4: the *mechanism* for this is not yet known to exist.
+- On unsupported SDK/project/server conditions, preserve syntax editing and
+  explain the next action; never silently switch language servers.
+- Reuse the existing Razor extension's assets only after recording the source,
+  commit, licence, notices, and any local modifications.
+- Do not modify a user's settings or installed extensions. Explain Razor file
+  association conflicts and provide migration instructions instead.
+- Do not add a debugger, application scaffolding, deployment/cloud tooling, or
+  legacy-framework semantic support in this roadmap.
+- Do not collect telemetry or upload project contents. Opening a Razor file
+  must not itself trigger restore or build work.
+
+### Platform constraints taken as given
+
+These are properties of Zed's extension model, not open questions. They are
+recorded here because two milestones below were originally written as though
+they did not hold.
+
+- A Zed extension is a WASM plugin. Its entire LSP surface is
+  `language_server_command`, `language_server_initialization_options`,
+  `language_server_workspace_configuration`, the two `additional_*` variants,
+  and `label_for_completion` / `label_for_symbol`. There is no hook to observe,
+  rewrite, or synthesise LSP traffic, and no concept of a virtual or projected
+  document. See zed-industries/zed#21133, closed as not planned.
+- Consequently, any Razor request/range bridging must run in a **separate proxy
+  executable** launched by `language_server_command`, which itself spawns
+  Roslyn and speaks LSP on both sides. See M4.2B.
+- Zed only ever opens real files, so such a proxy owns the virtual-document
+  lifecycle entirely — no virtual document can leak into ordinary editor
+  workflows unless the proxy emits one.
+- Attaching a server to a language is a manifest fact (`languages = [...]` plus
+  a `language_ids` map). Opting out is a user-side setting
+  (`"language_servers": ["!roslyn"]`), not an extension-side toggle.
+- Extensions cannot override query files shipped in a grammar's own repository
+  (zed#40532, closed as not planned). Queries under `languages/razor/*.scm` in
+  this repository do load; upstreaming query fixes to a grammar repo is not a
+  path.
+
+## Definition of done
+
+Every release must build cleanly, include user-facing documentation, preserve
+ordinary `.cs` behavior, and have regression coverage proportionate to its
+scope — where "coverage" means the harness built in M1.0, not an aspiration.
+Razor semantic support cannot be called stable until it passes the matrix in
+[Quality gates](#quality-gates).
+
+Each user-visible release also requires a version bump in `extension.toml` and
+`Cargo.toml` (the `bump_version` workflow handles this on merge) and a
+publishing PR to `zed-industries/extensions`. Batch M1.x into a single release;
+do not ship M3.4 in the same version as M1.5.
+
+## Decision gates
+
+The plan has three points where a negative answer changes the roadmap rather
+than delaying it. Each has a written else-branch. Do not proceed past a gate
+without recording the outcome in this file.
+
+| Gate | After | Question | Else-branch |
+| --- | --- | --- | --- |
+| G0 | M0.0 | Can the shipped `roslyn-language-server` package serve Razor at all? | See M0.0's three outcomes |
+| G1 | M0.2 | Which band does the best candidate land in? | Adopt / fork and vendor / descope M1 to injection-only |
+| G2 | M4.1 | Upstream route accepted within 30 days of a complete M3.3? | Extension-owned proxy route, or stop at experimental |
+
+Recorded outcomes: **G1 = fork and vendor** (2026-09-05,
+`docs/razor-grammar-audit.md`) — no candidate passed Adopt as-is; the chosen
+grammar was vendored and fixed to Adopt-band criteria. G0 and G2 pending.
+
+M3.3 additionally times out on its own: if there is no substantive Zed staff
+response within 30 days of posting, treat it as a decline for planning purposes
+and start the G2 clock.
+
+## Milestone 0 — Feasibility, foundation, and compatibility audit
+
+Goal: answer the questions that decide whether Milestones 3 and 4 exist, then
+remove the remaining unknowns before changing user-visible behavior.
+
+- [ ] **M0.0 — Razor/Roslyn feasibility spike (1–2 days, do this first)**
+  - Take the `roslyn-language-server.<rid>` package this extension already
+    downloads. Launch it by hand with `--stdio --autoLoadProjects` plus
+    `--razorSourceGenerator` and `--razorDesignTimePath`, against one Blazor
+    page and one `.cshtml` page.
+  - Drive it with a raw LSP client (a script is fine): `initialize`,
+    `textDocument/didOpen` with language id `aspnetcorerazor`, then
+    `textDocument/completion` and `textDocument/hover`.
+  - Context: dotnet/roslyn#82535 establishes that these flags exist but are
+    undocumented, and there is no maintainer statement that the standalone
+    `Microsoft.CodeAnalysis.LanguageServer` package serves Razor outside the
+    VS Code C# extension, which ships the Razor components separately.
+  - Acceptance: a written outcome, one of —
+    - **Works.** M3 is real; proceed as planned and record the exact flag
+      values and component versions in M3.1.
+    - **Needs components not in the package.** M3.1 becomes "acquire, licence,
+      and repackage the Razor components", a materially larger and
+      licence-sensitive job. Re-cost M3 before committing.
+    - **Does not work.** M3 and M4 collapse to "track upstream". M1 and M2
+      become the whole roadmap — an acceptable product outcome. Record it and
+      move on rather than retrying against newer packages ad hoc.
+
+- [x] **M0.1 — Inventory the extension's current contract** *(done 2026-09-05 —
+  `docs/inventory.md`)*
+  - Document language registrations, server installation/launch behavior,
+    project tasks, supported platforms, and user settings.
+  - Capture a baseline for `.cs`, `.csproj`, MSBuild, and `.slnx` behavior.
+  - Acceptance: a committed table mapping every later backlog item to the
+    source files and test files it touches. The table is the deliverable; a
+    prose audit is not.
+
+- [x] **M0.2 — Audit Razor grammar fitness and licence compatibility**
+  *(decided 2026-09-05 — G1 outcome: **fork and vendor**
+  `tris203/tree-sitter-razor` @ `d4664e4` (MIT) into
+  [joeizang/tree-sitter-razor](https://github.com/joeizang/tree-sitter-razor); three named grammar fixes applied; post-fix
+  the fork parses 14/14 well-formed corpus files with zero errors and 79/79
+  upstream tests. Full numbers, rejected candidates (licence-unverifiable
+  grammar; query-over-html non-candidate), and known pathological-containment
+  limits: `docs/razor-grammar-audit.md`.)*
+  - There is no canonical `tree-sitter-razor`. Candidates are small,
+    lightly-maintained third-party repositories (noundry/zed-razor,
+    IbrahimSabriOrene/zed-razor-treesitter, NoisKung/razor-syntex-zed).
+    Pinning one means adopting its bugs permanently.
+  - Verify licences for the grammar and every copied/adapted query file; add
+    required attribution/notices and record the upstream source revision.
+  - Decide now, in writing, whether this project is willing to maintain a Razor
+    grammar fork indefinitely. On current evidence it probably will have to.
+  - Acceptance: licence obligations are explicit, the grammar revision is
+    reproducible by automation, and the fitness numbers plus the fork decision
+    are recorded here.
+
+  **Fitness test and thresholds (set before running, not after).**
+
+  Parse each candidate over the M0.3a corpus at a pinned revision and record,
+  per file: whether the tree contains any `ERROR` or `MISSING` node, and the
+  share of file bytes covered by `ERROR` nodes. The two halves of the corpus
+  are judged differently, because a deliberately broken file *should* produce
+  errors.
+
+  *Core construct subset* — roughly fifteen well-formed files that must parse
+  cleanly for the extension to be worth shipping at all: implicit expression
+  (`@model.Name`), explicit expression (`@(a + b)`), `@code` and `@functions`
+  blocks, `@if` / `@foreach` / `@switch`, the directive set (`@page`, `@model`,
+  `@using`, `@inject`, `@inherits`, `@attribute`), a component with parameters
+  (`<Foo Bar="@x" />`), a Tag Helper (`asp-for`), `@bind` and `@onclick`,
+  layouts and `@section`, Razor comments (`@*…*@`), the `@@` escape, an email
+  address in body text, an `@media` rule inside `<style>`, and an `@` inside a
+  `<script>` block.
+
+  On the **well-formed** half, three measures are applied together:
+
+  | Band | Criteria | Action |
+  | --- | --- | --- |
+  | Adopt as-is | ≤5% of files contain any `ERROR`/`MISSING`, worst-file error span ≤10% of bytes, and **zero** core-construct failures | Pin upstream, no fork |
+  | Fork and fix | >5% and ≤25% of files affected, and ≤3 core-construct failures | Fork and vendor; the gaps are specific, nameable constructs |
+  | Reject | >25% of files affected, or >3 core-construct failures, or any single `ERROR` node spanning >50% of a file | Try the next candidate |
+
+  The >50%-span rule is separate on purpose: it means the parser derails and
+  never recovers, which no amount of query work repairs.
+
+  On the **pathological** half, errors are the expected outcome, so the gate is
+  *containment* rather than absence: the `ERROR` node must not extend to
+  end-of-file in more than 20% of those files, and constructs following the
+  broken one must still parse to their correct node types. This is M1.2's
+  "recover gracefully from incomplete templates" made measurable.
+
+  If every candidate lands in Reject, G1's else-branch applies: descope M1 to a
+  hand-written injection-only approach, or write a grammar.
+
+- [x] **M0.3a — Razor file corpus (gates M1)** *(done 2026-09-05 —
+  `corpus/razor/`: 14 well-formed + 10 pathological files; no secrets; input
+  to M0.2's fitness run and M1.0's harness)*
+  - A directory of `.razor` and `.cshtml` files only — no projects, no restore.
+  - Cover directives, Tag Helpers, layouts/partials, components and parameters,
+    scoped CSS, JS interop, and deliberately pathological cases: unterminated
+    blocks, mismatched tags, `@` in text and CSS, half-typed component tags.
+  - Acceptance: the corpus is the input to both M0.2's fitness test and M1.0's
+    snapshot harness, and contains no secrets.
+
+- [ ] **M0.3b — Buildable fixture solutions (gates M2 and M3)**
+  - Minimal restorable fixtures for MVC, Razor Pages, Blazor Web App, Blazor
+    WASM, Razor Class Library, and a multi-project solution, plus generated and
+    project-reload cases.
+  - Acceptance: fixtures open and restore deterministically on .NET 8+, offline
+    after a first restore, with no external-service dependency.
+
+- [ ] **M0.4 — Specify the Razor compatibility contract**
+  - Define `Razor` as a separate Zed language associated with `razor` and
+    `cshtml` suffixes.
+  - **Resolve the opt-in contradiction.** Attaching Roslyn to Razor requires
+    `extension.toml` to carry `languages = ["CSharp", "Razor"]` under
+    `[language_servers.roslyn]` plus a `[language_servers.roslyn.language_ids]`
+    map (`"Razor" = "aspnetcorerazor"`). The moment `"Razor"` appears there,
+    Zed starts Roslyn for every Razor buffer — so M1.5 ("editing only") and
+    M3.4 ("add an opt-in setting") cannot both hold under one manifest.
+    Determine whether extension-side conditional attachment is possible at all
+    (e.g. returning an error from `language_server_command` when a worktree
+    setting is absent — note this surfaces as an error, not a graceful no-op).
+    If it is not, then either M1 registers Razor with **no** server attached and
+    "opt-in" means "a later release", or "opt-in" means "a documented settings
+    edit". Pick one and write it down; an unwary M1 otherwise ships
+    experimental semantics silently.
+  - Define user-visible states: editing-only, experimental semantics, stable
+    semantics, unsupported environment, and conflicting extension.
+  - Acceptance: each state has an exact message, enabled capabilities, and a
+    recovery action; the opt-in mechanism is named and demonstrated.
+
+## Milestone 1 — First-class Razor editing
+
+Goal: make Razor files pleasant and structurally correct to edit without
+depending on a Razor language server. Gated on M0.3a and G1.
+
+- [ ] **M1.0 — Build the highlight snapshot harness**
+  - This repository currently has no tests: `.github/workflows/` contains only
+    the generated `bump_version.yml`, and `src/` has no test module. Every
+    "Acceptance: fixture snapshots…" below depends on this item existing first.
+  - Script the `tree-sitter` CLI (`highlight` / `query`) against the pinned
+    grammar plus this repository's `.scm` files over the M0.3a corpus, with
+    committed golden output and a diff-on-failure mode.
+  - Run it in CI on push. Extend it to the existing `csharp` and `msbuild`
+    queries so the C# regression blocker below is actually enforced.
+  - Acceptance: a deliberate query regression fails CI. If this item is
+    descoped, downgrade every snapshot acceptance criterion in M1 to an honest
+    manual checklist rather than leaving it unverifiable.
+
+- [ ] **M1.1 — Register the Razor grammar and language**
+  - Add a pinned Razor grammar registration to `extension.toml`.
+  - Migrate all three `[language_servers.*]` entries from the singular
+    `language = "CSharp"` form to the plural `languages = [...]` form, which is
+    the prerequisite for any `language_ids` mapping. All three are inherited
+    from upstream, so this is a merge-conflict hotspot — see D0.1.
+  - Add `languages/razor/config.toml` with `.razor` and `.cshtml` associations,
+    comments, bracket behavior, and safe editing defaults.
+  - Attach Razor to a language server only as M0.4 decided.
+  - Acceptance: opening either suffix selects `Razor`; ordinary `.cs` remains
+    `CSharp`; no language server starts for Razor buffers unless M0.4 says it
+    should.
+
+- [ ] **M1.2 — Implement syntax highlighting and injections**
+  - Add Razor query files for directives, expressions, control flow, comments,
+    C# blocks, and component/tag syntax.
+  - Inject HTML and coordinate embedded C# with existing language definitions.
+  - Preserve normal HTML/CSS/JS/TypeScript extension ownership.
+  - Note: graceful recovery from incomplete templates is a property of the
+    grammar chosen in M0.2, not of these queries. Failures here route back to
+    the fork decision.
+  - Acceptance: M1.0 snapshots correctly style Razor, C#, and HTML across the
+    corpus, including the pathological files.
+
+- [ ] **M1.3 — Implement structural editing support**
+  - Add bracket matching, auto-indentation, syntax overrides, outline, and
+    text objects where grammar support permits.
+  - Verify `@code`, `@section`, `@if`, `@foreach`, components, HTML elements,
+    Razor comments, and quoted attribute values.
+  - Acceptance: no auto-close/indent behavior corrupts a mixed-language file.
+
+- [ ] **M1.4 — Add focused Razor snippets and documentation**
+  - Provide conservative snippets for common directives and blocks; do not
+    replace framework scaffolding.
+  - Document supported files, known limits, settings, and coexistence/migration
+    from the separate Razor extension, and — the important one — the migration
+    off the upstream "C#" extension: uninstall it, install C# Plus, existing
+    `lsp.*` settings carry over unchanged. This is the doc that prevents the
+    duplicate-ownership problem Decision 0 accepted.
+  - Acceptance: a new user can install the extension, open a Razor project,
+    and understand the available editor features without trial-and-error.
+
+- [ ] **M1.5 — Release Razor editing support**
+  - Changelog: describe this as first-class *editing* support, not full Razor
+    IDE semantics.
+  - Version bump plus publishing PR to `zed-industries/extensions` adding the
+    `csharp-plus` entry, and the upstream merge required by D0.1.
+  - Acceptance: manual smoke tests pass on macOS, Linux, and Windows; no
+    duplicate file association is silently introduced; no language server
+    starts for Razor buffers.
+
+## Milestone 2 — Everyday .NET workflow
+
+Goal: make standard C# web work natural from a Zed project window. Gated on
+M0.3b.
+
+- [ ] **M2.1 — Roslyn-first project guidance**
+  - Document and test Roslyn as the recommended default for C# and required
+    backend for Razor semantics.
+  - Improve actionable diagnostics for missing SDKs, invalid `global.json`,
+    project-load failure, incompatible Roslyn components, and disabled Roslyn.
+  - Acceptance: each failure keeps files editable and identifies a concrete
+    remediation path.
+
+- [ ] **M2.2 — Add safe, parameterized .NET tasks**
+  - Provide discoverable restore, build, test, run, watch, and migration task
+    templates where Zed's task model supports them, extending the existing
+    `languages/csproj/tasks.json` and `languages/slnx/tasks.json`.
+  - Avoid running commands automatically and never expose connection strings or
+    launch-profile secrets.
+  - Acceptance: task definitions work against the M0.3b fixtures and are
+    documented for multi-project selection.
+
+- [ ] **M2.3 — Debugger handoff (conditional on a third-party adapter)**
+  - This item's original acceptance criterion depended on a .NET debug adapter
+    for Zed existing and working — which this project neither owns nor can
+    deliver. It is therefore conditional.
+  - If a usable adapter exists: document companion setup, task conventions, and
+    expected `launchSettings.json` behavior, and verify the documented path
+    launches and debugs a fixture app without debugger code being added here.
+  - If none exists: document the current state plainly, including that
+    debugging may not work, and how to troubleshoot a missing or incompatible
+    adapter. Do not block Milestone 2 on it.
+  - Acceptance: whichever branch applies is documented and dated.
+
+- [ ] **M2.4 — Project-file ergonomics audit**
+  - Confirm `.csproj`, `.props`, `.targets`, and `.slnx` coverage.
+  - Decide whether classic `.sln` needs extension-owned treatment or is already
+    correctly handled by Zed; avoid duplicate ownership.
+  - Acceptance: supported project files have a documented language association
+    and useful structure/highlighting.
+
+## Milestone 3 — Razor semantic proof of concept
+
+Goal: establish the smallest sustainable path to project-aware Razor semantics.
+**Exists only if G0 was positive.**
+
+- [ ] **M3.1 — Pin compatible Roslyn/Razor distribution**
+  - Record the exact Roslyn server distribution, Razor cohost component, SDK
+    requirements, argument values (as proven in M0.0), and supported runtime
+    identifiers.
+  - Never mix arbitrary Razor DLLs with an unrelated Roslyn version.
+  - If G0 landed on "needs components not in the package", this item first
+    covers acquiring, licensing, and repackaging those components, and must be
+    re-estimated before work starts.
+  - Acceptance: server startup is reproducible for each supported platform and
+    reports a clear version/component mismatch.
+
+- [ ] **M3.2 — Build the semantic capability probe**
+  - Attach Razor to Roslyn using the `aspnetcorerazor` language identifier via
+    the `language_ids` map from M1.1.
+  - Record dynamic registrations and Razor-specific client requests/notifications.
+  - Test C# completion, hover, diagnostics, navigation, references, rename,
+    actions, semantic tokens, folding, and formatting separately.
+  - Acceptance: an evidence table marking each capability as working, degraded,
+    unsupported by Zed, or requiring a bridge/core change.
+
+- [ ] **M3.3 — Propose the minimum upstream Zed capability**
+  - Open a Zed GitHub Discussion with the probe, real user value, protocol
+    trace, alternatives considered, test fixtures, and a minimal API/core design.
+  - Note that zed#21133 (LSP protocol extensions in extensions) was closed as
+    not planned; the proposal must argue why Razor is a different case rather
+    than re-raising a settled one.
+  - Obtain staff feedback before preparing a feature PR; sign the Zed CLA
+    before submitting to `zed-industries/zed`. (This is a contribution to Zed
+    core, and is unaffected by the fork decision — M3.3 and M4.2A concern Zed
+    itself, not the extension repository.)
+  - Acceptance: an explicit accept, revise, or decline outcome — or 30 days of
+    silence, which counts as a decline for planning purposes and starts G2.
+
+- [ ] **M3.4 — Publish experimental Razor semantics**
+  - Ship as its own release, separate from M1.5, using the opt-in mechanism
+    established in M0.4 with precise experimental wording.
+  - Enable only capabilities proven safe; specifically withhold formatting and
+    mapped edits unless virtual/projected document mapping is verified.
+  - Acceptance: turning it off returns immediately to complete editing support
+    with no data loss or configuration cleanup required.
+
+## Milestone 4 — Architecture gate and stable semantics
+
+Goal: choose a controlled, maintainable full-semantic implementation.
+
+- [ ] **M4.1 — Run the 30-day decision gate (G2)**
+  - Start the clock once M3.3 has a complete discussion/proof of concept, or
+    once M3.3's 30-day silence timeout expires.
+  - Choose the upstream route only with explicit Zed collaboration/acceptance.
+  - Otherwise begin the proxy-process feasibility design in M4.2B.
+  - The decision record must price both routes honestly. In particular, M4.2B
+    is **not** the cheaper option: see its cost note below.
+  - Acceptance: decision record identifies ownership, compatibility contract,
+    maintenance burden, and a migration/fallback plan. "Stop at experimental"
+    is a permitted outcome and must be considered explicitly.
+
+- [ ] **M4.2A — Upstream route (conditional)**
+  - Implement only the minimum accepted Zed capability for Razor-specific
+    requests and projected documents.
+  - Keep language registration, configuration, Roslyn distribution, fixtures,
+    and documentation in this extension.
+  - Acceptance: upstream tests and extension integration tests pass; no
+    dependency on unreleased behavior is advertised as stable.
+
+- [ ] **M4.2B — Proxy-process route (conditional)**
+  - **Architecture, stated precisely:** the bridge cannot live inside the
+    extension. It is a separate executable that `language_server_command`
+    returns; it spawns Roslyn as a child and speaks LSP on both sides, owning
+    virtual HTML documents and mapping requests, responses, ranges, edits,
+    diagnostics, and lifecycle events.
+  - Because Zed only opens real files, the proxy owns the virtual-document
+    lifecycle outright — nothing leaks into ordinary editor workflows unless
+    the proxy emits it. Range mapping must therefore be complete and lossless
+    in the proxy; there is no editor-side safety net.
+  - **Cost note for M4.1:** this means a second program, in a second language,
+    built and shipped per runtime identifier through the same download-and-
+    extract path `src/language_servers/nuget.rs` implements today, pinned
+    against a Roslyn version whose Razor protocol is undocumented, maintained
+    indefinitely. It roughly doubles the maintenance surface of this
+    repository. The fork means this is purely this project's call to make —
+    no maintainer has to be persuaded, and no one else absorbs the cost either.
+  - Define failure isolation, logging/redaction, update policy, and a fast
+    disable path that falls back to editing-only without a restart.
+  - Acceptance: protocol conformance and range-mapping fixtures pass; killing
+    the proxy degrades to editing-only rather than breaking the buffer.
+
+- [ ] **M4.3 — Stabilize Razor semantics**
+  - Make Roslyn Razor semantics the default only when the selected route passes
+    all quality gates.
+  - Enable Razor formatting only after correct formatting edits are proven.
+  - Keep OmniSharp and `csharp-ls` visibly C#-only for semantic expectations.
+  - Acceptance: release notes accurately distinguish stable behavior, optional
+    integrations, and unsupported legacy cases.
+
+## Quality gates
+
+### How the matrix actually gets run
+
+The matrix below is a 3-OS × 6-project-type × 10-operation space. One developer
+on one machine cannot execute it by hand per release, so it is split:
+
+- **Automated, every push (M1.0 harness + CI):** grammar/query snapshots over
+  the M0.3a corpus on Linux; build of the extension crate on all three OSes.
+- **Automated, per release:** server download and startup smoke on each
+  supported runtime identifier; task definitions against M0.3b fixtures.
+- **Manual, per release, checklist-driven:** the semantic-operation row and the
+  lifecycle row, on the developer's primary OS, with the other two OSes covered
+  by CI-executable smoke only.
+- Anything in the matrix with no home in the three buckets above is either
+  automated as part of the milestone that introduces it, or removed from the
+  matrix. An unrunnable gate is not a gate.
+
+### Functional matrix
+
+| Dimension | Required coverage |
+| --- | --- |
+| SDK | .NET 8 LTS and newer; `global.json` selection/failure |
+| OS | macOS (arm64/x64 where available), Linux, Windows |
+| Projects | MVC, Razor Pages, Blazor Web App, Blazor WASM, RCL, multi-project, multi-target |
+| Razor features | Directives, components/parameters, Tag Helpers, layouts/partials, page models, scoped CSS, JS interop, HTML/C#/CSS/JS embeddings |
+| Semantic operations | Completion, hover, diagnostics, definition, references, rename, actions, semantic tokens, folding, formatting |
+| Lifecycle | Cold open, restore/build, project reload, external edits, multiple worktrees, offline mode, stale/missing generated state, server mismatch |
+| Failure | Unsupported SDK/project, server launch failure, protocol error, malformed template, disabled Roslyn, conflicting Razor extension |
+
+### Release blockers
+
+- Incorrect mapped edit, range, diagnostic, or navigation target.
+- Formatting changes a location outside the intended Razor source range.
+- Crash, unbounded memory growth, or material startup/large-solution regression.
+- Silent server fallback, automatic build/restore, telemetry, or project-content
+  upload.
+- A regression in ordinary C# language/server behavior, as caught by the M1.0
+  harness extended over the existing `csharp` queries.
+- A language server starting for Razor buffers in a release that does not
+  advertise Razor semantics.
+
+## Out of scope
+
+- A new debugger or debug adapter.
+- Application generators/scaffolding.
+- Cloud/deployment management.
+- Guaranteed semantic support for classic ASP.NET/.NET Framework Razor.
+- Replacement implementations of HTML, CSS, JavaScript, or TypeScript support.
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..759eabc
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,46 @@
+# Changelog
+
+All notable changes to the C# Plus fork are documented here. Each entry that
+followed an upstream sync records the merged upstream commit (D0.1 policy).
+
+## Unreleased
+
+### 1.3.0 — Razor editing, workflow, and foundation (Milestone 0 + 1 + 2)
+
+The first fork release. Delivers the Milestone 0 foundation (feasibility,
+corpus, fixtures, contract), first-class Razor *editing* (Milestone 1), and the
+everyday .NET workflow improvements (Milestone 2). This is editing support, not
+full Razor IDE semantics: **no language server starts for Razor buffers in
+this release** (see `docs/razor-contract.md`).
+
+#### Added
+- Razor language (`Razor`) registered for `.razor` and `.cshtml` with the
+  pinned `tree-sitter-razor` grammar (M1.1; grammar decision in
+  `docs/razor-grammar-audit.md`).
+- Razor syntax highlighting, HTML/CSS/JS injections, bracket matching,
+  auto-indentation, outline, and text objects (M1.2, M1.3).
+- Razor snippets for common directives and blocks (M1.4).
+- Highlight snapshot harness over the committed Razor corpus plus the existing
+  `csharp` and `msbuild` queries, run in CI on every push (M1.0).
+- Discoverable `dotnet` task templates: restore, build, test, run, watch,
+  clean, publish, format, and EF Core migrations (M2.2).
+- Roslyn-first project guidance and actionable diagnostics for the common
+  failure modes (M2.1).
+- Documentation: migration off the upstream C# extension, debugging state,
+  supported files and known limits (M1.4, M2.3, M2.4).
+
+#### Fork infrastructure (D0.1)
+- Replaced upstream's `bump_version` workflow (gated on Zed org ownership and
+  Zed-internal secrets; could never run in the fork) with the manual
+  convention in `scripts/bump-version.sh` + `docs/versioning.md`.
+- Added the highlight/CI workflow story in `.github/workflows/ci.yml`.
+- Recorded upstream sync policy and registry verification in `docs/`.
+
+#### Decisions recorded
+- G0 (M0.0 outcome), G1 (M0.2 grammar decision), and the M0.4 opt-in
+  mechanism are recorded in `BACKLOG.md` and the referenced docs.
+
+## 1.2.2
+
+Fork point: upstream `zed-extensions/csharp` at commit `88597e1` (v1.2.2).
+Upstream history before this entry belongs to the upstream project.
diff --git a/Cargo.lock b/Cargo.lock
index c6b195d..1f270ff 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -738,7 +738,7 @@ dependencies = [
 ]
 
 [[package]]
-name = "zed_csharp"
+name = "zed_csharp_plus"
 version = "1.2.2"
 dependencies = [
  "zed_extension_api",
diff --git a/Cargo.toml b/Cargo.toml
index 375bed2..44fcf0b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "zed_csharp"
+name = "zed_csharp_plus"
 version = "1.2.2"
 edition = "2021"
 publish = false
diff --git a/README.md b/README.md
index c87fdc0..895c643 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,44 @@
-# Zed C#
+# Zed C# Plus
 
-A [C#](https://learn.microsoft.com/en-us/dotnet/csharp/) extension for [Zed](https://zed.dev).
+A [C#](https://learn.microsoft.com/en-us/dotnet/csharp/) and
+[Razor](https://learn.microsoft.com/en-us/aspnet/core/mvc/views/razor) extension
+for [Zed](https://zed.dev), covering C#, Razor (`.cshtml` / `.razor`), and .NET
+project files.
+
+## Provenance
+
+This is a fork of [zed-extensions/csharp](https://github.com/zed-extensions/csharp)
+at commit `88597e1` (version 1.2.2), which remains under the Apache-2.0 licence
+reproduced in [LICENSE](LICENSE). Original authorship is retained in
+`extension.toml`. Modifications made in this fork are tracked in the Git history
+and summarised per release in the changelog.
+
+## Relationship to the upstream C# extension
+
+C# Plus is a **superset** of the upstream extension, not a companion to it. It
+registers the same file suffixes (`.cs`, `.csproj`, `.slnx`, MSBuild files), so
+installing both will produce duplicate language ownership. Install one or the
+other:
+
+1. Uninstall the **C#** extension from Zed's extension list.
+2. Install **C# Plus**.
+
+Your existing `lsp.omnisharp` / `lsp.roslyn` / `lsp.csharp-ls` settings continue
+to work unchanged.
 
 ## Development
 
-To develop this extension, see the [Developing Extensions](https://zed.dev/docs/extensions/developing-extensions) section of the Zed docs.
+To develop this extension, see the [Developing Extensions](https://zed.dev/docs/extensions/developing-extensions)
+section of the Zed docs.
+
+### Staying current with upstream
+
+This fork tracks two remotes: `origin` is
+[joeizang/zed-csharp-plus](https://github.com/joeizang/zed-csharp-plus),
+`upstream` is [zed-extensions/csharp](https://github.com/zed-extensions/csharp).
+
+```sh
+git fetch upstream && git merge upstream/main
+```
+
+See `BACKLOG.md`, item D0.1, for the upstream-sync policy.
diff --git a/corpus/razor/pathological/at-in-css.cshtml b/corpus/razor/pathological/at-in-css.cshtml
new file mode 100644
index 0000000..151638b
--- /dev/null
+++ b/corpus/razor/pathological/at-in-css.cshtml
@@ -0,0 +1,13 @@
+@page "/email-css"
+
+<style>
+    .header {
+        background: @@eee;
+    }
+
+    @media print {
+        .header { background: none; }
+    }
+</style>
+
+<p>Styled page.</p>
diff --git a/corpus/razor/pathological/at-in-text.cshtml b/corpus/razor/pathological/at-in-text.cshtml
new file mode 100644
index 0000000..8e48953
--- /dev/null
+++ b/corpus/razor/pathological/at-in-text.cshtml
@@ -0,0 +1,8 @@
+@page "/social"
+
+<p>Meeting at 5@@3.</p>
+<p>Email bob@@example.com and alice@@example.org today.</p>
+<p>Handle: @@developer</p>
+<p>Almost email: bob@@</p>
+<p>Stray at: @@</p>
+<p>Normal text after the stray at-sign.</p>
diff --git a/corpus/razor/pathological/broken-attribute.cshtml b/corpus/razor/pathological/broken-attribute.cshtml
new file mode 100644
index 0000000..b69e82b
--- /dev/null
+++ b/corpus/razor/pathological/broken-attribute.cshtml
@@ -0,0 +1,7 @@
+@page "/quote-trouble"
+
+<img src="~/img/@Model.Name.png" alt="Logo" />
+<a href="@@">Escaped in attribute</a>
+<a href="@Model.Unterminated title>Broken quote</a>
+
+<p>Text after broken attribute quoting.</p>
diff --git a/corpus/razor/pathological/cascading-unterminated.cshtml b/corpus/razor/pathological/cascading-unterminated.cshtml
new file mode 100644
index 0000000..2075d11
--- /dev/null
+++ b/corpus/razor/pathological/cascading-unterminated.cshtml
@@ -0,0 +1,14 @@
+@page "/mixed-collapse"
+
+<div>
+@if (Model.Ready)
+{
+    <ul>
+    @foreach (var item in Model.Items)
+    {
+        <li>@item
+    </ul>
+</div>
+<span>after the collapse</span>
+@{
+<p>paragraph in open block</p>
diff --git a/corpus/razor/pathological/dangling-expressions.cshtml b/corpus/razor/pathological/dangling-expressions.cshtml
new file mode 100644
index 0000000..5555fd5
--- /dev/null
+++ b/corpus/razor/pathological/dangling-expressions.cshtml
@@ -0,0 +1,12 @@
+@page "/open-expression"
+
+<p>The value is @(Model.Value and the sentence keeps going.</p>
+<p>@Model.Unterminated</p>
+<p>Text after the dangling expressions.</p>
+
+@{
+    var a = 1;
+<p>Paragraph inside an open code block.</p>
+}
+
+<p>Final paragraph.</p>
diff --git a/corpus/razor/pathological/half-typed-component-tag.razor b/corpus/razor/pathological/half-typed-component-tag.razor
new file mode 100644
index 0000000..4f0d06a
--- /dev/null
+++ b/corpus/razor/pathological/half-typed-component-tag.razor
@@ -0,0 +1,12 @@
+@page "/new-component"
+
+<h1>Create</h1>
+
+<NewComponent
+<NestedPicker @bind-Value="Model.Value">
+    <span>inner</span>
+</NestedPicker>
+
+<ValidAfter />
+
+<p>Content after the half-typed tags.</p>
diff --git a/corpus/razor/pathological/mismatched-tags.cshtml b/corpus/razor/pathological/mismatched-tags.cshtml
new file mode 100644
index 0000000..e661f31
--- /dev/null
+++ b/corpus/razor/pathological/mismatched-tags.cshtml
@@ -0,0 +1,18 @@
+@page "/grid"
+
+<div class="grid">
+    <table>
+        <thead>
+            <tr><th>Col</th></tr>
+        </tbody>
+    </table>
+</div>
+
+@foreach (var row in Model.Rows)
+{
+    <tr>
+        <td>@row.First</td>
+    </tr>
+}
+
+<p>Recovered paragraph after mismatched tags.</p>
diff --git a/corpus/razor/pathological/odd-directives.cshtml b/corpus/razor/pathological/odd-directives.cshtml
new file mode 100644
index 0000000..9a85367
--- /dev/null
+++ b/corpus/razor/pathological/odd-directives.cshtml
@@ -0,0 +1,10 @@
+@page "/odd-directives"
+
+@whatever
+@123
+@@
+
+<p>@Model.Title</p>
+@Tag value in text
+
+<p>Final line after odd directives.</p>
diff --git a/corpus/razor/pathological/unterminated-comment.cshtml b/corpus/razor/pathological/unterminated-comment.cshtml
new file mode 100644
index 0000000..0612db5
--- /dev/null
+++ b/corpus/razor/pathological/unterminated-comment.cshtml
@@ -0,0 +1,8 @@
+@page "/comment-tangle"
+
+@* Comment that never terminates
+<div>
+    <p>Inside the unterminated comment</p>
+</div>
+
+<p>Paragraph after the unterminated comment.</p>
diff --git a/corpus/razor/pathological/unterminated-if-block.cshtml b/corpus/razor/pathological/unterminated-if-block.cshtml
new file mode 100644
index 0000000..143524e
--- /dev/null
+++ b/corpus/razor/pathological/unterminated-if-block.cshtml
@@ -0,0 +1,10 @@
+@page "/broken"
+
+<div>
+    @if (Model.Open)
+    {
+        <p>Started but the closing brace never arrives
+
+        <span>Nested content after the broken block</span>
+    </div>
+<p>This paragraph follows the unterminated block and must parse as an element.</p>
diff --git a/corpus/razor/well-formed/at-escapes-and-email.cshtml b/corpus/razor/well-formed/at-escapes-and-email.cshtml
new file mode 100644
index 0000000..548dac7
--- /dev/null
+++ b/corpus/razor/well-formed/at-escapes-and-email.cshtml
@@ -0,0 +1,6 @@
+@page "/pricing"
+
+<p>Contact us at support@example.com or sales@example.com.</p>
+<p>The @@ escape renders a literal at-sign: user@@example.com</p>
+<p>Prices start at @@5 per seat, up to @@25 for enterprise.</p>
+<p>Social handles: @@zed_admin and @@dotnet.</p>
diff --git a/corpus/razor/well-formed/bind-and-events.razor b/corpus/razor/well-formed/bind-and-events.razor
new file mode 100644
index 0000000..7295a27
--- /dev/null
+++ b/corpus/razor/well-formed/bind-and-events.razor
@@ -0,0 +1,28 @@
+@page "/settings"
+@using System.ComponentModel.DataAnnotations
+
+<h1>Settings</h1>
+
+<input @bind="Enabled" />
+<input @bind="Model.Quantity" @bind:after="SaveQuantity" />
+<input type="checkbox" @bind="Model.Accepted" />
+<select @bind="Region">
+    <option value="eu">Europe</option>
+    <option value="us">United States</option>
+</select>
+
+<button @onclick="() => Toggle(Enabled)">Toggle</button>
+<button @onclick="@(e => Save(e))">Save</button>
+
+@code {
+    private bool Enabled { get; set; }
+    private string Region { get; set; } = "eu";
+
+    private void Toggle(bool value)
+    {
+        Enabled = !value;
+    }
+
+    private Task Save(System.EventArgs e) => Task.CompletedTask;
+    private Task SaveQuantity() => Task.CompletedTask;
+}
diff --git a/corpus/razor/well-formed/code-block.razor b/corpus/razor/well-formed/code-block.razor
new file mode 100644
index 0000000..87f45f9
--- /dev/null
+++ b/corpus/razor/well-formed/code-block.razor
@@ -0,0 +1,24 @@
+@page "/counter"
+@using System.ComponentModel.DataAnnotations
+@inject CounterState State
+
+<h3>Counter</h3>
+
+<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
+
+@code {
+    private int currentCount = 0;
+
+    [Parameter]
+    public int StartFrom { get; set; }
+
+    protected override void OnInitialized()
+    {
+        currentCount = StartFrom;
+    }
+
+    private void IncrementCount()
+    {
+        currentCount += State.Step;
+    }
+}
diff --git a/corpus/razor/well-formed/component-parameters.razor b/corpus/razor/well-formed/component-parameters.razor
new file mode 100644
index 0000000..64f54a3
--- /dev/null
+++ b/corpus/razor/well-formed/component-parameters.razor
@@ -0,0 +1,15 @@
+@page "/orders"
+
+<OrderCard Order="@Model.CurrentOrder" Highlight="true" />
+<OrderCard Order="@Model.PreviousOrder">
+    <CardHeader>Previous order</CardHeader>
+</OrderCard>
+
+@code {
+    private Dictionary<string, object> extra = new()
+    {
+        ["data-testid"] = "order-card"
+    };
+}
+
+<OrderCard Order="@Model.DraftOrder" Extra="@extra" />
diff --git a/corpus/razor/well-formed/directives-and-control-flow.cshtml b/corpus/razor/well-formed/directives-and-control-flow.cshtml
new file mode 100644
index 0000000..0c38335
--- /dev/null
+++ b/corpus/razor/well-formed/directives-and-control-flow.cshtml
@@ -0,0 +1,45 @@
+@page "/products"
+@model ProductsModel
+@using MyApp.Models
+@inject IProductRepository Repository
+@inherits BasePage
+@attribute [Authorize]
+
+<h1>Products</h1>
+
+@foreach (var product in Model.Products)
+{
+    <div class="product">
+        <span>@product.Name</span>
+        <span>@product.Price</span>
+    </div>
+}
+
+@switch (Model.Category)
+{
+    case "books":
+        <p>Browse books</p>
+        break;
+    case "toys":
+        <p>Browse toys</p>
+        break;
+    default:
+        <p>Browse everything</p>
+        break;
+}
+
+@if (Model.Products.Any())
+{
+    @if (Model.Products.Count > 10)
+    {
+        <p>Large catalog</p>
+    }
+    else
+    {
+        <p>Small catalog</p>
+    }
+}
+else
+{
+    <p>Catalog is empty</p>
+}
diff --git a/corpus/razor/well-formed/explicit-expressions.cshtml b/corpus/razor/well-formed/explicit-expressions.cshtml
new file mode 100644
index 0000000..2682fac
--- /dev/null
+++ b/corpus/razor/well-formed/explicit-expressions.cshtml
@@ -0,0 +1,13 @@
+@page "/cart"
+@model CartModel
+
+<p>Subtotal: @(Model.Subtotal.ToString("C"))</p>
+<p>Tax: @(Model.Subtotal * 0.08m)</p>
+<p>Total: @(Model.Subtotal + Model.Subtotal * 0.08m)</p>
+<p>Items: @(Model.Items?.Count ?? 0)</p>
+
+@{
+    var label = Model.Items.Count == 1 ? "item" : "items";
+}
+
+<span>@(Model.Items.Count) @label</span>
diff --git a/corpus/razor/well-formed/functions-block.razor b/corpus/razor/well-formed/functions-block.razor
new file mode 100644
index 0000000..6383e7a
--- /dev/null
+++ b/corpus/razor/well-formed/functions-block.razor
@@ -0,0 +1,12 @@
+@functions {
+    public string Greeting { get; set; } = "hello";
+
+    public void Reset()
+    {
+        Greeting = "";
+    }
+}
+
+<h1>@Greeting</h1>
+
+<button @onclick="Reset">Reset</button>
diff --git a/corpus/razor/well-formed/layouts-and-sections.cshtml b/corpus/razor/well-formed/layouts-and-sections.cshtml
new file mode 100644
index 0000000..e178d38
--- /dev/null
+++ b/corpus/razor/well-formed/layouts-and-sections.cshtml
@@ -0,0 +1,21 @@
+@page "/dashboard"
+@model DashboardModel
+@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
+
+<h1>@ViewData["Title"]</h1>
+
+<div class="row">
+    @await Html.PartialAsync("_Summary", Model)
+</div>
+
+<div class="row">
+    @await Component.InvokeAsync("Stats")
+</div>
+
+@section Scripts {
+    <script src="~/js/dashboard.js" asp-append-version="true"></script>
+}
+
+@section Styles {
+    <link rel="stylesheet" href="~/css/dashboard.css" />
+}
diff --git a/corpus/razor/well-formed/mixed-statements.cshtml b/corpus/razor/well-formed/mixed-statements.cshtml
new file mode 100644
index 0000000..22af460
--- /dev/null
+++ b/corpus/razor/well-formed/mixed-statements.cshtml
@@ -0,0 +1,35 @@
+@page "/layout-demo"
+
+<h1>Page content</h1>
+
+@{
+    Layout = "_ColumnLayout";
+    var columns = new[] { "alpha", "beta", "gamma" };
+}
+
+<div class="columns">
+    @for (var i = 0; i < columns.Length; i++)
+    {
+        <section class="col">
+            @columns[i]
+        </section>
+    }
+</div>
+
+@while (false)
+{
+    <span>never</span>
+}
+
+@try
+{
+    <span>@Model.Risky</span>
+}
+catch (InvalidOperationException ex)
+{
+    <span class="error">@ex.Message</span>
+}
+finally
+{
+    <span>done</span>
+}
diff --git a/corpus/razor/well-formed/pages-implicit-expressions.cshtml b/corpus/razor/well-formed/pages-implicit-expressions.cshtml
new file mode 100644
index 0000000..fa1fb29
--- /dev/null
+++ b/corpus/razor/well-formed/pages-implicit-expressions.cshtml
@@ -0,0 +1,27 @@
+@page "/contacts"
+@model ContactsModel
+@{
+    ViewData["Title"] = "Contacts";
+}
+
+<h2>Contacts</h2>
+
+<table>
+    <thead>
+        <tr><th>Name</th><th>Email</th></tr>
+    </thead>
+    <tbody>
+        @foreach (var contact in Model.Contacts)
+        {
+            <tr>
+                <td>@contact.Name</td>
+                <td>@contact.Email</td>
+            </tr>
+        }
+    </tbody>
+</table>
+
+@if (Model.Contacts.Count == 0)
+{
+    <p>No contacts yet.</p>
+}
diff --git a/corpus/razor/well-formed/razor-comments.cshtml b/corpus/razor/well-formed/razor-comments.cshtml
new file mode 100644
index 0000000..dd88725
--- /dev/null
+++ b/corpus/razor/well-formed/razor-comments.cshtml
@@ -0,0 +1,17 @@
+@page "/notes"
+@model NotesModel
+
+@* This page shows archived notes *@
+@* Multi-line comment
+   spanning several lines
+   @inject Nothing Here *@
+<div class="notes">
+    @foreach (var note in Model.Notes)
+    {
+        @* Render the note title and body *@
+        <article>
+            <h3>@note.Title</h3>
+            <p>@note.Body</p>
+        </article>
+    }
+</div>
diff --git a/corpus/razor/well-formed/script-block.cshtml b/corpus/razor/well-formed/script-block.cshtml
new file mode 100644
index 0000000..3a0bfe9
--- /dev/null
+++ b/corpus/razor/well-formed/script-block.cshtml
@@ -0,0 +1,13 @@
+@page "/analytics"
+
+<script>
+    window.dataLayer = window.dataLayer || [];
+    function gtag(){dataLayer.push(arguments);}
+    gtag('js', new Date());
+
+    var userId = '@Model.UserId';
+    var endpoint = '@Url.Content("~/api/analytics")';
+    if (userId) { gtag('config', 'G-EXAMPLE', { user_id: userId }); }
+</script>
+
+<p>Analytics @Model.Status</p>
diff --git a/corpus/razor/well-formed/style-media-rule.razor b/corpus/razor/well-formed/style-media-rule.razor
new file mode 100644
index 0000000..5333b97
--- /dev/null
+++ b/corpus/razor/well-formed/style-media-rule.razor
@@ -0,0 +1,24 @@
+@page "/theme"
+
+<style>
+    @media (max-width: 600px) {
+        .card {
+            padding: 0.5rem;
+        }
+    }
+
+    .accent {
+        color: @Model.AccentColor;
+    }
+
+    .content {
+        content: "@Model.QuotedValue";
+    }
+</style>
+
+<div class="card">Themed content</div>
+
+@code {
+    public string AccentColor { get; set; } = "#3fb27f";
+    public string QuotedValue { get; set; } = "css-safe";
+}
diff --git a/corpus/razor/well-formed/tag-helpers.cshtml b/corpus/razor/well-formed/tag-helpers.cshtml
new file mode 100644
index 0000000..76794dc
--- /dev/null
+++ b/corpus/razor/well-formed/tag-helpers.cshtml
@@ -0,0 +1,20 @@
+@page "/profile"
+@model ProfileModel
+
+<form method="post">
+    <div class="form-group">
+        <label asp-for="DisplayName"></label>
+        <input asp-for="DisplayName" class="form-control" />
+        <span asp-validation-for="DisplayName" class="text-danger"></span>
+    </div>
+    <div class="form-group">
+        <label asp-for="Email"></label>
+        <input asp-for="Email" type="email" class="form-control" />
+        <span asp-validation-for="Email" class="text-danger"></span>
+    </div>
+    <button type="submit" class="btn btn-primary">Save</button>
+</form>
+
+<environment include="Development">
+    <p>Development mode diagnostics enabled</p>
+</environment>
diff --git a/docs/inventory.md b/docs/inventory.md
new file mode 100644
index 0000000..0fcc258
--- /dev/null
+++ b/docs/inventory.md
@@ -0,0 +1,71 @@
+# Extension inventory and contract (M0.1)
+
+Baseline of what the extension registers and how it behaves, and the mapping
+from every later backlog item to the source and test files it touches. **This
+table is the M0.1 deliverable**; update it as items land.
+
+## Current contract (baseline at fork point `88597e1`)
+
+### Language registrations
+
+| Language | Path suffixes | Grammar | Tasks | Notes |
+| --- | --- | --- | --- | --- |
+| `CSharp` | `cs` | `tree-sitter-c-sharp` @ `485f0bae` | — | `autoclose_before = ";:.,=}])>"`, `//` and `///` comments, string-aware quote pairs |
+| `C# Project File` | `csproj` | `tree-sitter-xml` @ `863dbc38` (xml) | restore/build current project | |
+| `MSBuild File` | `proj`, `props`, `targets` | `tree-sitter-xml` (xml) | — | |
+| `C# Solution File` | `slnx` | `tree-sitter-xml` (xml) | restore/build current solution | |
+
+### Language servers (all attached to `CSharp` only, singular `language =` form)
+
+| Server id | Install | Launch | Settings surface |
+| --- | --- | --- | --- |
+| `omnisharp` | GitHub release asset `OmniSharp/omnisharp-roslyn` (`omnisharp-{os}-{arch}-net6.0.{tar.gz,zip}`), cached dir `omnisharp-{version}` | binary directly, `-lsp` default arg; `which OmniSharp` short-circuit; `binary.path` override | `binary` only |
+| `roslyn` | NuGet `roslyn-language-server.{win,linux,osx}-{x64,arm64}`, cached dir `roslyn-{version}`, self-contained exe or `dotnet exec` fallback (`any` rid) | `--stdio --autoLoadProjects` + user args; `binary.path` override | `binary`; `settings` mapped through `csharp\|` key flattening, inlay hints and reference/test code lenses defaulted |
+| `csharp-ls` | NuGet `csharp-ls`, cached dir `csharp-ls-{version}`; `which csharp-ls` short-circuit; requires `dotnet` on PATH otherwise | `dotnet exec .../CSharpLanguageServer.dll` | `binary`; `settings` wrapped as `{"csharp": ...}` |
+
+Supported platform matrix in code: `{win,linux,osx} × {x64,arm64}` (six RIDs),
+plus a `dotnet exec` fallback path (`rid = any`). Extension API surface used:
+`language_server_command`,
+`language_server_workspace_configuration` (Roslyn, csharp-ls only),
+`set_language_server_installation_status`, `download_file`,
+`latest_github_release`, `make_file_executable`, `which`, `http_client`.
+
+### What the extension does NOT do today
+
+- No tests, no CI of its own (only the generated `bump_version.yml`).
+- No Razor anything: no `.razor`/`.cshtml` registration, no grammar, no queries.
+- No `.sln` (classic) association.
+- No initialization-options hook usage.
+
+## Backlog-item → file map
+
+The authoritative mapping; every item below must keep this table accurate.
+
+| Item | Source files touched | Test/verification files |
+| --- | --- | --- |
+| D0.1 | `.github/workflows/*`, `scripts/bump-version.sh`, `CHANGELOG.md`, `README.md`, `extension.toml` (authors), `docs/{versioning,upstream-sync,publishing}.md` | CI green; registry verification date in `docs/publishing.md` |
+| M0.0 | — (spike; no product code) | `docs/feasibility-spike.md`, `scripts/spike/*.py` artifacts |
+| M0.1 | `docs/inventory.md` (this file) | — |
+| M0.2 | `extension.toml` (`[grammars.razor]`), `docs/razor-grammar-audit.md` | `harness/` fitness numbers, `corpus/razor/**` |
+| M0.3a | `corpus/razor/**` | input to M0.2 + M1.0 harness |
+| M0.3b | `fixtures/**`, `fixtures/README.md` | `scripts/verify-fixtures.sh`, release smoke |
+| M0.4 | `docs/razor-contract.md`, `BACKLOG.md` (decision), `extension.toml` (per decision) | M1.5 smoke: no server for Razor |
+| M1.0 | `harness/**`, `.github/workflows/ci.yml`, `scripts/snapshot.sh` | golden outputs `harness/golden/**`; deliberate-regression check |
+| M1.1 | `extension.toml`, `languages/razor/config.toml` | M1.0 harness; M1.5 smoke |
+| M1.2 | `languages/razor/{highlights,injections}.scm` | `harness/golden/razor/**` |
+| M1.3 | `languages/razor/{brackets,indents,outline,textobjects,runes}.scm`, `languages/razor/config.toml` | `harness/golden/razor/**` (outline/textobjects/indents snapshots) |
+| M1.4 | `languages/razor/snippets.json`, `README.md`, `docs/{migration,known-limits}.md` | manual smoke checklist |
+| M1.5 | `CHANGELOG.md`, `extension.toml` + `Cargo.toml` versions, `docs/publishing.md`, `docs/release-smoke.md` | macOS/Linux/Windows smoke, dated in changelog |
+| M2.1 | `src/language_servers/roslyn.rs` (error messages), `docs/dotnet-workflow.md` | manual: each failure keeps files editable; documented remediation |
+| M2.2 | `languages/csproj/tasks.json`, `languages/slnx/tasks.json`, `docs/dotnet-workflow.md` | task definitions against `fixtures/**` (release smoke) |
+| M2.3 | `docs/debugging.md` | dated doc decision |
+| M2.4 | `docs/project-files.md`, possibly `languages/msbuild/config.toml` | documented associations |
+| M3.1 | `src/language_servers/roslyn.rs` + `razor_support.rs`, `docs/roslyn-razor-pinning.md` | reproducible startup script `scripts/spike/*`; version-mismatch error |
+| M3.2 | `scripts/probe_razor.py`, `src/language_servers/razor_support.rs` | `docs/razor-probe-results.md` evidence table |
+| M3.3 | `docs/upstream-proposal.md` (discussion artifact) | outcome recorded in `BACKLOG.md` G2 |
+| M3.4 | `extension.toml` (`language_ids` map), `src/language_servers/roslyn.rs` (initialization options gating), `CHANGELOG.md` (own release) | opt-in/opt-out documented and demonstrated |
+| M4.1 | `docs/gate-g2-decision.md` | decision record completeness |
+| M4.2A | (conditional; not taken) | — |
+| M4.2B | `proxy/**` (separate crate), `src/language_servers/proxy.rs` | `proxy/tests/**` range-mapping + conformance fixtures; kill-test |
+| M4.3 | `docs/quality-gates.md`, `CHANGELOG.md` (own release), `src/language_servers/*` default flip | gate matrix executed |
+| Quality gates | `docs/{quality-gates,manual-checklist,release-smoke}.md`, `harness/`, `.github/workflows/ci.yml`, `scripts/release-smoke.sh` | the gates themselves |
diff --git a/docs/publishing.md b/docs/publishing.md
new file mode 100644
index 0000000..02404d5
--- /dev/null
+++ b/docs/publishing.md
@@ -0,0 +1,30 @@
+# Publishing
+
+## One-time registry entry
+
+Publishing requires a PR to [zed-industries/extensions](https://github.com/zed-industries/extensions)
+adding `csharp-plus` as a new entry in `extensions.toml`:
+
+```toml
+[csharp-plus]
+submodule = "extensions/csharp-plus"
+version = "1.3.0"
+```
+
+The id `csharp-plus` was verified free on **2026-09-05** (the registry then
+contained `csharp` and `csharp-snippets` only). Re-verify before opening the
+PR; if it has been taken, stop and reconsider the extension id before
+releasing — a renamed id after first publish breaks upgrades.
+
+## Per-release checklist
+
+1. Upstream merged per [upstream-sync.md](upstream-sync.md); commit recorded in
+   the changelog.
+2. Version bumped via `scripts/bump-version.sh` (see [versioning.md](versioning.md)).
+3. CI green on the release commit (harness + builds on all three OSes).
+4. Release smoke pass per [release-smoke.md](release-smoke.md) on the
+   developer's primary OS; the other two OSes covered by CI-executable smoke.
+5. Manual checklist from [manual-checklist.md](manual-checklist.md) executed
+   and dated in the changelog entry.
+6. Publishing PR opened; merge order: registry PR after the version commit
+   lands on `origin/main`.
diff --git a/docs/razor-grammar-audit.md b/docs/razor-grammar-audit.md
new file mode 100644
index 0000000..1b5170b
--- /dev/null
+++ b/docs/razor-grammar-audit.md
@@ -0,0 +1,116 @@
+# Razor grammar audit and decision (M0.2, gate G1)
+
+Status: **decided 2026-09-05**. Outcome recorded in `BACKLOG.md`.
+
+## Candidates considered
+
+There is no canonical `tree-sitter-razor`. The three candidates named in the
+backlog were evaluated at the revisions below:
+
+| Candidate | Kind | Licence | Verdict |
+| --- | --- | --- | --- |
+| [tris203/tree-sitter-razor](https://github.com/tris203/tree-sitter-razor) @ `d4664e409caaea12f73c9525484e3cf88b1cf718` | real grammar (embeds `tree-sitter-c-sharp`) | MIT © 2023 Tristan Knight, LICENSE file present, actively maintained (July 2026) | **chosen — forked** |
+| [IbrahimSabriOrene/zed-razor-treesitter](https://github.com/IbrahimSabriOrene/zed-razor-treesitter) @ `ed8e4c6e9bb9749352fd6197457f2406f9290a88` | real grammar at repo root | package.json declares MIT but **no LICENSE file exists**; author field is template residue ("Your Name") | rejected — licence obligations cannot be verified; also fails the `@@`-escape core construct (45.77% of file in ERROR) |
+| [NoisKung/razor-syntex-zed](https://github.com/NoisKung/razor-syntex-zed) @ `07d7334a8987a6323544c532c7127e3e010d7291` | **not a grammar** — queries over the stock `html` grammar | MIT | not a grammar candidate; it is the G1 "injection-only" else-branch shape, kept as a design reference only |
+
+## Fitness test method
+
+`scripts/grammar-fitness.py` parses the M0.3a corpus (`corpus/razor/`) with the
+candidate grammar and reports, per file: presence of `ERROR`/`MISSING` nodes,
+share of file bytes inside outermost `ERROR` spans, and (pathological half)
+whether the error extends to end-of-file. Bands were fixed in the backlog
+**before** running. The corpus at audit time: 14 well-formed + 10 pathological
+files.
+
+## Results at the pinned upstream revision (tris203, `d4664e4`)
+
+- Well-formed half: **3/14 files affected (21.43%)**, worst single `ERROR`
+  span **99.73%** of a file (`razor-comments.cshtml`) — auto-Reject by the
+  >50% rule as-is.
+- Pathological half: **4/10 (40%)** errors extend to EOF (gate: ≤20%).
+- Upstream's own corpus: 78/79 (one pre-existing failure fixed by the fork,
+  see below).
+- Upstream's tests never exercise a `@* … *@` comment inside a braced razor
+  block; that construct fails on upstream too (verified against pristine
+  `d4664e4`).
+
+All three well-formed failures were **specific, nameable constructs**:
+
+1. A `@* … *@` comment as the first item of any braced razor block
+   (`@code`, `@if`, `@{ … }`, `@foreach` body) derailed the whole file.
+2. `@media`/`@supports`/… in `<style>` lexed as a Razor implicit expression;
+   the selector prelude then derailed as a bogus explicit expression.
+3. Parenthesized lambdas in attribute values (`@onclick="() => Fn()"`), plus
+   explicit expressions in values (`@onclick="@(e => Save(e))"`), lost the
+   `(`-ambiguity and broke neighbouring lines through GLR interaction.
+
+## Fork decision and fixes (G1: fork)
+
+**Decision: fork** `tris203/tree-sitter-razor` into a grammar repository of
+its own, [joeizang/tree-sitter-razor](https://github.com/joeizang/tree-sitter-razor), pinned by commit from `extension.toml` exactly as the
+`c_sharp` and `xml` grammars are. The project accepts maintaining this grammar
+fork indefinitely (recorded as required by the backlog; on current evidence it
+was always likely). Forking rather than referencing upstream keeps fixes off
+upstream's review queue; keeping the grammar in its own repository rather than
+vendored keeps this repository small (a vendored copy is ~48 MB, cloned by
+every user at install), lets the grammar version independently of the
+extension, and avoids a pin that can only be written after the merge it refers
+to.
+
+The fork revision in use is pinned in `extension.toml`.
+
+Local modifications, all in `grammar.js` (documented in the file header):
+
+1. **Root cause of the comment derailment was not the comment's lexer.** It
+   was `razor_comment` being listed both in `extras` and as a `_node` member:
+   at the start of a `repeat` (a fresh block body) the extra-path and the
+   item-path fork and the structural parse starves. **Fix: removed
+   `razor_comment` from `extras`** (it remains a first-class `_node`
+   member, so it still parses everywhere a `_node` can appear). The comment
+   text rule was left as upstream so C# comments still parse as children
+   inside a razor comment, matching upstream's expected trees.
+2. **`css_at_rule`** for CSS at-rules (`@media`, `@supports`, `@keyframes`,
+   …) with a prelude token stopping at `{`/`;`. `@page` is deliberately
+   **not** claimed — it is a Razor directive in `.cshtml` (and `@namespace`
+   likewise: claiming it broke upstream's own Namespace test).
+3. **`razor_attribute_value`** gained `prec.left(1)` and accepts
+   `razor_explicit_expression`, so `@onclick="() => Fn()"` and
+   `@onclick="@(e => Save(e))"` parse cleanly.
+
+Fix 1 also fixes upstream's pre-existing failing test ("Namespace" initially
+failed under fix 2 until `@namespace` was removed from the CSS list; the
+pre-existing "Commented Code Block" interaction required fix 1 to be the
+extras-removal form rather than a single-token comment body).
+
+## Results after the fork fixes
+
+- Upstream corpus: **79/79**.
+- M0.3a corpus, well-formed half: **14/14 clean — 0% affected, 0% worst-file
+  span, 0 core-construct failures → Adopt-band criteria met by the fork**.
+- Pathological half: 3/10 outermost `ERROR` spans extend to EOF (30%;
+  aspirational gate ≤20%). Of these:
+  - `cascading-unterminated.cshtml` ends *inside* the unterminated `@{` block;
+    an ERROR reaching EOF is the only correct outcome by construction.
+  - `unterminated-if-block.cshtml`: every construct after the break —
+    including the trailing `<p>` — parses to its correct node type inside the
+    ERROR wrapper; only the outer span reaches EOF.
+  - `broken-attribute.cshtml`: the unterminated attribute quote swallows the
+    remainder; the trailing `<p>` is not recovered. **Known limit**, inherited
+    from upstream (worse there: 65% of the file in one ERROR span), recorded
+    for M1.2. A grammar-level fix (terminating quoted values at `>`) would
+    break legitimate `>` inside attribute values and was rejected.
+
+## Licence and attribution obligations
+
+- The grammar is MIT; `LICENSE` is retained unmodified at the root of the
+  grammar repository.
+- The grammar repository's README carries a fork notice naming upstream, the pinned
+  commit, and the local modifications; `grammar.js` carries the same in its
+  header. Apache-2.0's "mark modifications" obligation is satisfied by these
+  notices.
+- If any upstream query file is later copied or adapted into
+  `languages/razor/*.scm`, its header must name the upstream repository,
+  revision, licence, and the local changes (tracked under M1.2).
+- Fork hygiene for grammar updates: re-run `scripts/grammar-fitness.py` over
+  the corpus and `tree-sitter test` in the grammar checkout after every
+  upstream merge (D0.1) or grammar change; both are wired into CI (M1.0).
diff --git a/docs/upstream-sync.md b/docs/upstream-sync.md
new file mode 100644
index 0000000..02f3878
--- /dev/null
+++ b/docs/upstream-sync.md
@@ -0,0 +1,38 @@
+# Upstream sync policy (D0.1)
+
+`upstream` points at `zed-extensions/csharp`; `origin` points at the fork
+(`joeizang/zed-csharp-plus`).
+
+## Policy
+
+- Fetch and merge `upstream/main` **at the start of every milestone** and
+  **before any release**.
+- Record the merged upstream commit in `CHANGELOG.md` for that release.
+- Divergence is cheapest to resolve while small. The files most likely to
+  conflict are:
+  - `languages/csharp/*.scm`
+  - `src/language_servers/roslyn.rs`
+  - `extension.toml`
+
+```sh
+git fetch upstream && git merge upstream/main
+```
+
+## Attribution obligations (must survive every merge)
+
+- `LICENSE` (Apache-2.0) is retained unmodified. The licence requires that
+  notices be preserved and modifications be marked.
+- Upstream authors stay listed in `extension.toml`.
+- Fork provenance and the fork-point commit stay in `README.md`.
+- Copied/adapted assets (grammar queries, fixtures) carry their own
+  attribution headers — see [razor-grammar-audit.md](razor-grammar-audit.md).
+
+If a merge would drop any of the above, the merge is wrong; fix it before
+committing.
+
+## Registry
+
+Publishing requires a PR to `zed-industries/extensions` adding `csharp-plus`
+as a new entry. The id was verified free on 2026-09-05 (the registry then
+contained `csharp` and `csharp-snippets`, but no `csharp-plus`); re-verify
+before M1.5 per docs/publishing.md.
diff --git a/docs/versioning.md b/docs/versioning.md
new file mode 100644
index 0000000..8ff75b3
--- /dev/null
+++ b/docs/versioning.md
@@ -0,0 +1,34 @@
+# Versioning and releases
+
+This fork replaces upstream's generated `bump_version` GitHub workflow with the
+manual convention below.
+
+## Why the workflow was removed
+
+`.github/workflows/bump_version.yml` (generated from `xtask` inside the Zed
+repository) was gated on
+`github.repository_owner == 'zed-industries' || 'zed-extensions'` and invoked a
+reusable workflow from `zed-industries/zed` requiring the Zed-internal
+`ZED_ZIPPY_APP_*` secrets. Under the fork's owner it could never run, and even
+ungated it would fail on the missing secrets. Decision (D0.1): **replace it
+with a manual version-bump convention** so the repository has exactly one
+workflow story. All CI now lives in `.github/workflows/ci.yml`.
+
+## How to release
+
+1. Merge `upstream/main` per the [sync policy](upstream-sync.md) and record the
+   merged upstream commit in `CHANGELOG.md`.
+2. Run `scripts/bump-version.sh <major|minor|patch| --set X.Y.Z>`. It bumps
+   `version` in both `extension.toml` and `Cargo.toml` and refreshes
+   `Cargo.lock`.
+3. Add the `CHANGELOG.md` entry (commit it together with the bumps).
+4. Open the publishing PR to `zed-industries/extensions` per
+   [publishing.md](publishing.md).
+
+## Release sequencing rules (from the backlog)
+
+- M1.x ships as a single release; Razor semantic work (M3.4) must not ship in
+  the same version as M1.5.
+- Every user-visible release needs: a clean build, user-facing documentation,
+  unchanged ordinary `.cs` behavior, and harness coverage proportionate to its
+  scope.
diff --git a/extension.toml b/extension.toml
index 574bae7..acc5dd1 100644
--- a/extension.toml
+++ b/extension.toml
@@ -1,13 +1,16 @@
-id = "csharp"
-name = "C#"
-description = "C# support."
+id = "csharp-plus"
+name = "C# Plus"
+description = "C#, Razor, and .NET project support."
 version = "1.2.2"
 schema_version = 1
+# Upstream authors of zed-extensions/csharp, retained per the Apache-2.0
+# NOTICE requirements. See README.md for the fork's provenance.
 authors = [
     "fminkowski <fminkowski@gmail.com>",
     "Fabian Freimueller <fabianfreimueller@gmail.com>",
+    "Joseph Izang <josephizang@gmail.com>",
 ]
-repository = "https://github.com/zed-extensions/csharp"
+repository = "https://github.com/joeizang/zed-csharp-plus"
 
 [language_servers.omnisharp]
 name = "OmniSharp"
diff --git a/scripts/__pycache__/grammar-fitness.cpython-314.pyc b/scripts/__pycache__/grammar-fitness.cpython-314.pyc
new file mode 100644
index 0000000..4da0aa8
Binary files /dev/null and b/scripts/__pycache__/grammar-fitness.cpython-314.pyc differ
diff --git a/scripts/bump-version.sh b/scripts/bump-version.sh
new file mode 100644
index 0000000..5cf1f38
--- /dev/null
+++ b/scripts/bump-version.sh
@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+# Manual version-bump convention for the C# Plus fork (D0.1).
+#
+# Upstream's generated `bump_version` workflow is gated on
+# `repository_owner == 'zed-industries' || 'zed-extensions'` and invokes a
+# reusable workflow that requires Zed-internal secrets. Neither works under
+# the fork's owner, so the fork uses this script instead. This is the one
+# documented version-bump mechanism; see docs/versioning.md.
+#
+# Usage:
+#   scripts/bump-version.sh <major|minor|patch>   # bump from current version
+#   scripts/bump-version.sh --set X.Y.Z           # set an explicit version
+#
+# The script bumps `version` in extension.toml and Cargo.toml, refreshes
+# Cargo.lock, and prints the changelog entry you must add before committing.
+
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+current() {
+    sed -n 's/^version = "\(.*\)"$/\1/p' extension.toml | head -n1
+}
+
+bump() {
+    local kind=$1 version
+    version=$(current)
+    IFS=. read -r major minor patch <<<"$version"
+    case "$kind" in
+        major) major=$((major + 1)); minor=0; patch=0 ;;
+        minor) minor=$((minor + 1)); patch=0 ;;
+        patch) patch=$((patch + 1)) ;;
+        *) echo "unknown bump kind: $kind" >&2; exit 1 ;;
+    esac
+    echo "$major.$minor.$patch"
+}
+
+if [[ "${1:-}" == "--set" ]]; then
+    new_version="${2:?usage: bump-version.sh --set X.Y.Z}"
+elif [[ "${1:-}" =~ ^(major|minor|patch)$ ]]; then
+    new_version=$(bump "$1")
+else
+    echo "usage: bump-version.sh <major|minor|patch|--set X.Y.Z>" >&2
+    exit 1
+fi
+
+old_version=$(current)
+
+sed -i '' "0,/^version = \"/s/^version = \"[^\"]*\"/version = \"$new_version\"/" extension.toml
+sed -i '' "0,/^version = \"/s/^version = \"[^\"]*\"/version = \"$new_version\"/" Cargo.toml
+cargo update --workspace --quiet
+
+echo "bumped $old_version -> $new_version"
+echo
+echo "Next steps (do not skip):"
+echo "  1. Add a CHANGELOG.md entry for $new_version, recording the"
+echo "     upstream commit merged per the D0.1 sync policy (if any)."
+echo "  2. Commit both version bumps, Cargo.lock, and the changelog together."
+echo "  3. Open the publishing PR to zed-industries/extensions (docs/publishing.md)."
diff --git a/scripts/grammar-fitness.py b/scripts/grammar-fitness.py
new file mode 100644
index 0000000..455e21a
--- /dev/null
+++ b/scripts/grammar-fitness.py
@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+"""Grammar fitness test (M0.2) — run a tree-sitter grammar over the Razor corpus.
+
+Measures, per file: presence of ERROR/MISSING nodes, share of file bytes
+covered by ERROR spans, and — for the pathological half — whether the error
+extends to end-of-file and whether content after the break still parses to
+correct node types.
+
+Usage:
+  grammar-fitness.py <grammar-dir> <corpus-dir> [--json OUT]
+
+The grammar-dir must already have `tree-sitter generate` applied (or a
+committed src/parser.c) so `tree-sitter parse` works. Bands (well-formed half):
+
+  Adopt as-is   <=5% of files with any ERROR/MISSING, worst-file span <=10%,
+                zero core-construct failures
+  Fork and fix  >5% and <=25% of files, <=3 core-construct failures
+  Reject        >25% of files, >3 core-construct failures, or any single ERROR
+                spanning >50% of a file
+
+Pathological half gate is containment: ERROR extends to EOF in <=20% of files.
+"""
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+# File -> core constructs it exercises (backlog M0.2 list).
+CORE_CONSTRUCTS = {
+    "pages-implicit-expressions.cshtml": ["implicit expression", "@foreach", "@if"],
+    "explicit-expressions.cshtml": ["explicit expression"],
+    "code-block.razor": ["@code block", "@onclick", "@inject", "@using", "@page", "@parameter"],
+    "functions-block.razor": ["@functions block"],
+    "directives-and-control-flow.cshtml": ["@page", "@model", "@using", "@inject", "@inherits", "@attribute", "@switch", "@foreach", "@if"],
+    "component-parameters.razor": ["component with parameters"],
+    "tag-helpers.cshtml": ["tag helper (asp-for)"],
+    "bind-and-events.razor": ["@bind", "@onclick"],
+    "layouts-and-sections.cshtml": ["@section", "layout/partial"],
+    "razor-comments.cshtml": ["razor comment"],
+    "at-escapes-and-email.cshtml": ["@@ escape", "email in text"],
+    "style-media-rule.razor": ["@media in <style>", "expression in CSS"],
+    "script-block.cshtml": ["@ in <script>"],
+    "mixed-statements.cshtml": ["@for", "@try/catch", "layout"],
+}
+
+NODE = re.compile(r"\(([A-Za-z_][A-Za-z0-9_]*)")
+SPAN = re.compile(r"\[(\d+), (\d+)\] - \[(\d+), (\d+)\]")
+
+
+def parse_file(grammar_dir: Path, path: Path) -> tuple[str, int]:
+    proc = subprocess.run(
+        ["tree-sitter", "parse", str(path.resolve())],
+        cwd=grammar_dir,
+        capture_output=True,
+        text=True,
+    )
+    return proc.stdout + proc.stderr, proc.returncode
+
+
+def error_spans(tree: str) -> list[tuple[int, int, int, int]]:
+    """Return (start_row, start_col, end_row, end_col) for every outermost
+    ERROR node in a tree S-expression dump.
+
+    Tree-sitter nests children inside ERROR nodes (each repeating a range),
+    and the CLI's trailing summary line repeats the widest span, so nested and
+    duplicated spans are dropped: only spans not contained in another span are
+    returned.
+    """
+    raw: list[tuple[int, int, int, int]] = []
+    for m in re.finditer(r"\(ERROR", tree):
+        r = SPAN.search(tree, m.start())
+        if r:
+            raw.append(tuple(int(g) for g in r.groups()))
+    outer = [
+        s
+        for s in raw
+        if not any(s is not t and _contains(t, s) for t in raw)
+    ]
+    return outer
+
+
+def _contains(
+    big: tuple[int, int, int, int], small: tuple[int, int, int, int]
+) -> bool:
+    return (big[0], big[1]) <= (small[0], small[1]) and (small[2], small[3]) <= (
+        big[2],
+        big[3],
+    )
+
+
+def has_missing(tree: str) -> bool:
+    return "(MISSING" in tree
+
+
+def col_bytes(lines: list[str], row: int, col: int) -> int:
+    # CLI reports byte columns; clamp defensively.
+    if row >= len(lines):
+        return 0
+    return min(col, len(lines[row].encode()))
+
+
+def span_bytes(lines: list[str], span: tuple[int, int, int, int]) -> int:
+    (r1, c1, r2, c2) = span
+    total = 0
+    if r1 == r2:
+        total = col_bytes(lines, r2, c2) - col_bytes(lines, r1, c1)
+    else:
+        total = len(lines[r1].encode()) - col_bytes(lines, r1, c1)
+        for r in range(r1 + 1, r2):
+            total += len(lines[r].encode()) + 1
+        total += col_bytes(lines, r2, c2)
+    return max(total, 0)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("grammar_dir")
+    ap.add_argument("corpus_dir")
+    ap.add_argument("--json", dest="json_out")
+    args = ap.parse_args()
+
+    grammar_dir = Path(args.grammar_dir)
+    corpus = Path(args.corpus_dir)
+    files = sorted(corpus.rglob("*.razor")) + sorted(corpus.rglob("*.cshtml"))
+
+    report = {"grammar": str(grammar_dir), "corpus": str(corpus), "files": {}}
+    wf_affected = 0
+    wf_total = 0
+    worst_span = 0.0
+    cc_failures = 0
+    eof_extension = 0
+    path_total = 0
+
+    for path in files:
+        rel = path.relative_to(corpus).as_posix()
+        text = path.read_bytes()
+        n_bytes = len(text)
+        lines = text.decode("utf-8", "replace").splitlines()
+        out, rc = parse_file(grammar_dir, path)
+        # The CLI's trailing summary line (`<path>\tParse: ...`) repeats the
+        # widest error span; drop it so only tree output is scanned.
+        tree_only = out.split(f"\tParse:", 1)[0]
+        spans = error_spans(tree_only)
+        covered = sum(span_bytes(lines, s) for s in spans)
+        pct = covered / n_bytes * 100 if n_bytes else 0.0
+        last_line = len(lines) - 1
+        last_len = len(lines[last_line].encode()) if lines else 0
+        to_eof = bool(spans) and all(
+            (s[2], s[3]) >= (last_line, max(last_len - 1, 0)) for s in spans
+        )
+        entry = {
+            "returncode": rc,
+            "error_nodes": len(spans),
+            "missing_nodes": has_missing(out),
+            "error_bytes": covered,
+            "error_pct": round(pct, 2),
+            "error_reaches_eof": to_eof,
+        }
+        pathological = "pathological" in rel
+        if pathological:
+            path_total += 1
+            if to_eof:
+                eof_extension += 1
+        else:
+            wf_total += 1
+            if spans or entry["missing_nodes"]:
+                wf_affected += 1
+            worst_span = max(worst_span, pct)
+        report["files"][rel] = entry
+
+    report["summary"] = {
+        "well_formed_total": wf_total,
+        "well_formed_affected": wf_affected,
+        "well_formed_affected_pct": round(wf_affected / wf_total * 100, 2) if wf_total else 0,
+        "worst_file_error_pct": round(worst_span, 2),
+        "pathological_total": path_total,
+        "pathological_eof_extension": eof_extension,
+        "pathological_eof_pct": round(eof_extension / path_total * 100, 2) if path_total else 0,
+    }
+
+    # Core-construct verdicts are recorded by the auditor in
+    # docs/razor-grammar-audit.md; the tree dump per file is the evidence.
+    if args.json_out:
+        Path(args.json_out).write_text(json.dumps(report, indent=2))
+    print(json.dumps(report["summary"], indent=2))
+    for rel, entry in report["files"].items():
+        flag = "EOF" if entry["error_reaches_eof"] else ("err" if entry["error_nodes"] or entry["missing_nodes"] else "ok ")
+        print(f"  {flag}  {entry['error_pct']:6.2f}%  {rel}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())