0.2.0: mcpp-vscode 1.1.0 is mcpp-vscode 0.9.0 over the backend; one page library for VS Code and CLion; CLion's API on 261-263

.gitattributes

@@ -2,3 +2,4 @@
 * text=auto eol=lf
 protocol/fixtures/** -text
 *.png binary
+tests/rules/corpus/** -text

.github/versions.env

@@ -1,14 +1,15 @@
 # The versions CI builds and tests with, in one file; .github/actions/setup-mcpp exports them.
-# The released mcpp CI installs and uses: the control contract the fixtures were captured from
-# (protocol/fixtures/version.txt) and the platforms (openkal-platform 0.17.3) the backend's ok images
-# are built on.
-MCPP_VERSION=2026.10.27.1
+# The released mcpp CI installs and uses: it states its features (`features`, the project's mcpp of
+# part 2 §4.3), test-launch among them (2026.10.31.2), and builds the backend's ok images on
+# openkal-platform 0.18.0. The mock replays the control contract the fixtures were captured from
+# (protocol/fixtures/version.txt).
+MCPP_VERSION=2026.10.31.2
 # A ref of mcpp-community/mcpp CI builds mcpp from and uses instead, for a contract not yet released.
 # Empty: the release above is used.
 MCPP_SOURCE_REF=
 # The LLVM the backend builds with on macOS and Windows (the targets mcpp reaches there with it).
 LLVM_VERSION=23.1.3
-# The xlings mcpp 2026.10.27.1 bundles, which reads the current index.
+# The xlings mcpp 2026.10.31.2 bundles, which reads the current index.
 XLINGS_VERSION=v2026.10.26.1
 # The oldest VS Code the extension supports (engines.vscode), which its tests run in.
 VSCODE_VERSION=1.91.0

.github/workflows/release.yml

@@ -36,6 +36,27 @@ jobs:
           mkdir -p dist
           cp artifacts/mcpp-vscode-vsix/*.vsix artifacts/mcpp-clion-zip/*.zip dist/
           cp artifacts/backend/mcpp-ide.okb "dist/mcpp-ide-${version}.okb"
-          cp "artifacts/backend/mcpp-ide-${version}-openkal.tar.gz" dist/
+          cp "artifacts/backend/mcpp-ide-${version}"-openkal*.tar.gz dist/
           (cd dist && sha256sum * > SHA256SUMS && cat SHA256SUMS)
           gh release create "v${version}" dist/* --target "$GITHUB_SHA" --title "mcpp-ide ${version}" --notes-file CHANGELOG.md
+      # Open VSX receives the exact VSIX attached to the GitHub Release; the Visual Studio
+      # Marketplace and the JetBrains Marketplace receive the same assets through their portals.
+      - uses: actions/setup-node@v5
+        with:
+          node-version: 22
+      - name: Publish to Open VSX
+        env:
+          OPENVSX_TOKEN: ${{ secrets.OPENVSX_TOKEN }}
+        run: |
+          set -euo pipefail
+          if [ -z "${OPENVSX_TOKEN:-}" ]; then
+            echo "OPENVSX_TOKEN is not set: Open VSX is a required destination of a release."
+            echo "Create a token with the publish scope at open-vsx.org (Settings, Access Tokens) and add it"
+            echo "as the OPENVSX_TOKEN secret of this repository (Settings, Secrets and variables, Actions)."
+            exit 1
+          fi
+          (cd mide-plugins/vscode && npm ci --ignore-scripts)
+          vsix="$(ls dist/mcpp-vscode-*.vsix)"
+          (cd mide-plugins/vscode && npx ovsx publish "$GITHUB_WORKSPACE/$vsix" --pat "$OPENVSX_TOKEN")
+      - name: The Marketplaces
+        run: echo "Upload the GitHub Release VSIX manually to Visual Studio Marketplace, and the CLion zip to JetBrains Marketplace."

.xlings.json

@@ -1,5 +1,5 @@
 {
   "workspace": {
-    "mcpp": "2026.10.27.1"
+    "mcpp": "2026.10.31.2"
   }
 }

CHANGELOG.md

@@ -1,5 +1,125 @@
 # Changelog
 
+## 0.2.0
+
+mcpp-vscode 1.1.0, mcpp-clion 0.2.0 and mcpp-nvim 0.2.0 (mcpp design 2026-10-29 §10).
+
+- **The project's mcpp (mcpp design 2026-10-30 part 2 §4).** Each project is asked in its own
+  directory, `mcpp self env --format json` through the program a version manager's shim stands for
+  (or `mcpp.path`), with `XLINGS_PROJECT_DIR` removed from every run of mcpp, so a project pinned in
+  `.xlings.json` is described by the mcpp that builds it. A feature is turned on by what the project's
+  mcpp states (`features`, mcpp 2026.10.31.1) or, for an earlier mcpp, by a table frozen at that
+  release, never by comparing versions. A pinned version that is not installed is `pinned-missing`,
+  with the shim's words and its install command; an untrusted workspace's project is not asked. A
+  job whose envelope names another version, the editor regaining focus and a changed manifest each
+  make the project be asked again; never more than two at once. Methods `project/mcpp`,
+  `project/refresh`, `capabilities/explain` (why a feature is not offered: which party, which
+  capability, from which version) and `report/collect`; notification `project/mcppChanged`.
+- **The backend's lifecycle and what it says (§3).** VS Code and CLion start an ended backend again
+  after 1, 4 and 16 seconds; a fourth end within three minutes leaves them in the degraded mode with
+  two actions, restarting the backend and exporting the IDE report. **mcpp: Export IDE Report**
+  (every editor; Neovim `:Mcpp exportReport [path]`) writes the backend, every project's mcpp,
+  mcppls's status, the settings in effect, recent jobs and the backend's recent log to a file the
+  person names. `mcpp.backend.logLevel` decides what the backend writes to the editor's log. VS
+  Code's status item names the project's mcpp version, and its tooltip the program and whether
+  `mcpp.path` chose it.
+- **What mcppls says about the workspace (§5).** The backend's `languageService/status` runs
+  `mcppls status --root <dir> --format json` (mcppls 0.0.20 and later, bounded at five seconds) and
+  returns its capabilities, the workspace's state, engine and kit, the servers serving it, and
+  mcppls's actions under each editor's own id; for mcppls 0.0.18 and 0.0.19 the actions come from a
+  table frozen at those releases. A different answer is sent once (`languageService/changed`). The
+  command table's forwards name mcppls's action ids, and `commands/list` gives each editor the id
+  mcppls states for it: CLion runs the mcppls plugin's action (and hides a row it does not have),
+  Neovim mcppls-nvim's command. VS Code reads the state and the commands from this answer instead of
+  the mcppls extension's API object and keeps only the confirmation each action needs; the state is
+  asked again after a job, on focus, when the project view becomes visible and, while it is visible,
+  at most every 30 seconds. A missing semantic kit is a row with **C++ Modules: Install the Semantic
+  Kit**. After a build nothing is forwarded by default (`auto`): mcppls reads mcpp's result record.
+- **Entries (§6).** The backend's `source/entries` says what a C++ file is to its project -- a
+  program's `main`, a test's (`tests/**`, named as mcpp names it), or neither -- with the line of
+  `main` read from the text, outside comments and literals. VS Code shows Run and Debug above `main`
+  (`mcpp.codeLens.enable`), at the position C++ Modules gives and otherwise at the line read, said to
+  be approximate; Build and Debug join Run and Test in the editor's title bar, and Run, Debug, Build
+  and Test are in the editor's context menu. The command table states these places (`placements`),
+  and the generator writes VS Code's menus and CLion's editor popup from it. CLion's ▶ stands on the
+  PSI element `main` on the line the backend read, the IDE's Build (the hammer) of an mcpp project is
+  `mcpp build`, a status bar item shows the project's mcpp and the running job with the quick menu,
+  and two keymaps (`mcpp`, `mcpp (macOS)`) carry VS Code's chords.
+- **Test cases (§7).** `spec/test-frameworks.json` describes GoogleTest, Catch2 and doctest: a test
+  program belongs to one when its plan holds the framework's package and its source calls the
+  framework's macros (`mcpp.test.macros` adds a project's own). `test/cases` reads the cases from the
+  source and, after a build in a trusted workspace, from the program's own listing; `test/runCases`
+  runs some of them with the framework's filter and reads its report, each outcome sent as
+  `test/caseResult`. VS Code's Testing view has the cases under their program, located at their
+  macros, and the program at its `main`; CLion has a ▶ on each case and runs cases in its test tree.
+  Debugging a test's program is offered where the project's mcpp describes its launch (`test-launch`,
+  mcpp 2026.10.31.2).
+- **The rules layer of mcpp.toml and build.mcpp, in the backend (§8; docs/rules.md).** The session
+  is an LSP server, protocol 2: `initialize` in LSP's shape with mcpp-ide's parameters in
+  `initializationOptions`, mcpp.toml's and build.mcpp's completion, hover, jumps and diagnostics as
+  `textDocument/*` (full synchronisation, UTF-16 columns), and mcpp-ide's own methods and
+  notifications under `mcpp-ide/`. The tolerant scanner, the seven manifest rules and the SPEC-007
+  checks are ported from mcpp-vscode 0.9's TypeScript, whose answers over a corpus at every position
+  are the tests' goldens (`tests/rules`). A table is read through the schema (a workspace table as the
+  table it mirrors, a platform's table under a selector as the platform's); a selector-only table is
+  offered with its selector; the schema's own arrays of tables are allowed; a dependency's version is
+  completed from mcpp's catalogue (`mcpp search --format json`) when `mcpp.toml.indexCompletion` is
+  on. VS Code connects with its language client (bundled into `dist/vendor`); CLion over the
+  session's connection, through a completion contributor, an annotator, a documentation provider
+  and a go-to-declaration handler; Neovim with its LSP client, attached to mcpp.toml and build.mcpp
+  buffers. While C++ Modules serves build.mcpp (`mcpplsServes`) it is left the unknownSymbol rule
+  and the module names after `import`. One snapshot of each: `spec/toml-schema.json`,
+  `spec/buildscript-api.json` (mcpp 2026.10.29.1's directives).
+- **CLion in its own components (§9).** The "mcpp" tool window's Project, Libraries and Cache tabs
+  are native trees and lists over the backend's view models (each project's mcpp, targets, tests,
+  libraries, last build, artifacts and platform, and what C++ Modules says; the indexes' packages, a
+  package's page and adding it to the project; what mcpp keeps and the command table's cleanups with
+  their confirmations). A graph of the packages or the modules is the one page in JCEF
+  (`webui/graph.html`, mermaid over `graph/packages` and `graph/modules`; a module opens its source),
+  tested in Chromium over a real backend. Settings | Tools | mcpp is a form generated from
+  `settings/registry`, with Apply, Reset and a search. The workbench that ran mcpp-vscode's pages in
+  JCEF, its `vscode` shim and its bridge are removed; the views' models and the settings form are
+  tested headless.
+- **The declared degraded mode (§8, F15).** Where the package's okrun does not run (macOS x86_64,
+  Windows arm64, Linux armhf) VS Code says the backend does not run on this platform and goes on
+  with build, run, test and the project pages, running mcpp's queries itself; an Extension Host run
+  in CI holds it.
+- **mcpp-vscode 1.1.0 is mcpp-vscode 0.9.0 over the backend.** 0.9.0's extension is imported with
+  its history (`mide-plugins/vscode`); every view, page, command, menu, setting and string a user
+  sees is 0.9.0's. What 1.0 added stays, in 0.9.0's style: debugging (`mcpp.debug`, the `mcpp`
+  launch type), the test tree, the target picker with target-set rows, packing, build on save,
+  cancellable jobs. mcpp is run through the backend's `mcpp/exec`, mcppls through its
+  `languageService/exec`; the extension starts no other process for mcpp or mcppls.
+- **Parity gates against 0.9.0.** The manifest's contributions and strings contain 0.9.0's exactly
+  (`spec/` states them; `mcpp-ide-dev gen vscode` writes the manifest); every page's document,
+  rendered by the extension's generators, is byte-identical to the snapshot rendered by 0.9.0's;
+  the Extension Host suite runs over the bundled backend.
+- **One page library for VS Code and CLion.** The workbench (`webui/`) runs mcpp-vscode's page
+  modules unchanged in a browser host: the `vscode` module and Node's built-ins are answered by
+  the host's bridge, views are tabs, webviews are iframes with the IDE's `--vscode-*` theme.
+  mcpp-clion's tool window and its settings page are this workbench in JCEF; the earlier panels
+  (`webui/js`) are removed. A Chromium test runs the workbench over a real backend.
+- **Backend methods.** `mcpp/exec` (a bounded mcpp run: timeout, output limit, truncation reported),
+  `languageService/exec` (the located mcppls with arguments), `project/files` (manifest, lock and
+  the source count 0.9.0 shows); `targets` rows for target sets (`set`, `members`, `label`) when mcpp
+  is 2026.10.30.1 or later.
+- **The mcpp logo in CLion.** mcpp-clion's plugin icon and its tool window's icon are the mcpp
+  logo, as mcpp-vscode's and mcppls's are; the text icons (`m++`, `m+`) are removed. CI checks that
+  both embed the logo and that the VS Code logo is 0.9.0's.
+- **mcpp-clion on 2026.1 through 2026.3.** Trust through `TrustedProjects.isProjectTrusted`, debug
+  sessions through `XDebuggerManager.newSessionBuilder`, the debugger driver through
+  `createDriverConfiguration(project, CPPEnvironment(toolchain))`; packing is a job over the
+  backend's `pack/formats`.
+- **mcpp 2026.10.31.2.** One pack of the target set `openkal` writes the editor packages' tree and
+  okb (`--target openkal --mode self-contained --systems all --pkg-format tar,okb`); CI reads
+  `runs_on`; the Windows launcher is `bin/mcpp-ide.exe`, built over a platform other than mcpp's own
+  openkal rows'. The backend is on mcpplibs.os 0.2.6 and openkal-platform 0.20.2, ok images included
+  (openkal 0.19, whose okrun releases the image file once loaded and verifies an okb's chunk digests on
+  several contexts, and whose C library serves threads that allocate together from their own caches).
+- **CI and release.** 0.9.0's gates run in this repository (registry, translations, unit suite on
+  three systems, manifest drift, parity, Extension Host on three systems, isolated install, the
+  graph page in Chromium); the release publishes the VSIX to Open VSX beside the GitHub release.
+
 ## 0.1.1
 
 mcpp-vscode 1.0.1, mcpp-clion 0.1.1 and the first mcpp-nvim (0.1.1), with mcppls 0.0.19.

README.md

@@ -15,11 +15,12 @@ different tool.
 
 mcpp-ide makes them once. Its backend, `mcpp-ide serve`, is a C++ program that reads only mcpp's
 machine contract (event streams, result records, launch descriptors, JSON queries) and answers the
-editors over JSON-RPC. The VS Code extension and the CLion plugin map those answers onto their own
-UI and share one set of web panels; the Neovim plugin maps them onto buffers, floating windows and
-the quickfix list. The editor plugins are `mide-plugins/` of this repository. Language features of
-C++ files come from [mcppls](https://github.com/Sunrisepeak/mcpp-language-server); mcpp-ide
-registers none.
+editors as an LSP server (JSON-RPC, protocol 2). The VS Code extension's views and pages are
+mcpp-vscode 0.9.0's; the CLion plugin shows the same information in CLion's own trees, lists and
+settings form (a graph in JCEF), and the Neovim plugin maps the answers onto buffers, floating
+windows and the quickfix list. The editor plugins are `mide-plugins/` of this repository. Language
+features of C++ files come from [mcppls](https://github.com/Sunrisepeak/mcpp-language-server);
+those of mcpp.toml and build.mcpp come from the backend ([docs/rules.md](docs/rules.md)).
 
 ## Features
 
@@ -29,8 +30,9 @@ registers none.
 | Test tree, re-run one test | Testing view | IDE test runner | `:Mcpp test <filter>` |
 | Debug | CodeLLDB, C/C++ (gdb, lldb), lldb-dap | CLion's GDB or LLDB | nvim-dap (codelldb, lldb-dap, cppdbg, gdb) |
 | Diagnostics | Problems, from mcpp's located diagnostics | Console links to the reported location | `vim.diagnostic`, `:Mcpp problems` in the quickfix list |
-| mcpp.toml | Problems from mcpp; completion, hover, outline from mcpp's key registry | Problems from mcpp | Problems from mcpp |
-| Targets and platforms, libraries, graphs, cache, pack, settings | Shared web panels | The same panels (JCEF) | Text in floating windows, `vim.ui.select`; settings in `setup()` |
+| mcpp.toml, build.mcpp | Completion, hover, jumps and the rules' diagnostics from the backend (language client); Problems from mcpp | The same, through CLion's completion, documentation, annotations and go-to | The same, through `vim.lsp`; mcpp's problems in `vim.diagnostic` |
+| Libraries, a package's page, graphs, cache, settings | mcpp-vscode's views and pages | Native trees and lists, a settings form from the registry, the graphs in JCEF | Text in floating windows, `vim.ui.select`; settings in `setup()` |
+| Targets (target sets among them), pack | Quick picks | Popups | `vim.ui.select` |
 | Language features | mcppls (installed with the extension) | mcppls CLion plugin (a dependency) | mcppls-nvim (`xlings install mcppls-nvim`) |
 
 - **One answer everywhere** -- what a build runs, how a test is reported, what a cleanup costs: the backend's
@@ -57,10 +59,10 @@ the editor I use (VS Code, CLion or Neovim) from its latest release, and check i
 | VS Code-compatible editors | Open VSX, or the `.vsix` | install the `.vsix` from the extensions view |
 | CLion 2026.1+ | JetBrains Marketplace (`mcpp-clion`), or `mcpp-clion-<version>.zip` | Settings → Plugins → Install Plugin from Disk; the mcppls CLion plugin (its package for this system carries the server) first |
 | Neovim 0.10+ | `mide-plugins/nvim` of the release's source tree | `xlings install mcpp-ide-nvim` (the backend with it, set up at start); or the directory on the runtimepath and `require('mcpp').setup()` ([its README](mide-plugins/nvim/README.md)) |
-| Agents, other clients | `mcpp-ide-<version>-openkal.tar.gz` (both images; okrun for Linux x64/arm64, macOS arm64, Windows x64), `mcpp-ide-<version>.okb` with okrun, or `xlings install mcpp-ide` | run `bin/mcpp-ide serve` (`bin\mcpp-ide.cmd` on Windows), or `okrun mcpp-ide-<version>.okb serve` |
+| Agents, other clients | `mcpp-ide-<version>-openkal-bundle-all.tar.gz` (both images; okrun for Linux x64/arm64, macOS arm64, Windows x64), `mcpp-ide-<version>.okb` with okrun, or `xlings install mcpp-ide` | run `bin/mcpp-ide serve` (`bin\mcpp-ide.exe` on Windows), or `okrun mcpp-ide-<version>.okb serve` |
 
 Each editor package serves every system: it carries the backend as one ok-image bundle
-(`backend/mcpp-ide.okb`, the x86_64 and aarch64 images on openkal-platform 0.17.3) and okrun for
+(`backend/mcpp-ide.okb`, the x86_64 and aarch64 images on openkal-platform 0.20.2) and okrun for
 Linux x64/arm64, macOS arm64 and Windows x64. The Neovim plugin carries none: it starts the
 `mcpp-ide` command xlings installs (okrun on the same bundle).
 
@@ -69,7 +71,8 @@ Linux x64/arm64, macOS arm64 and Windows x64. The Neovim plugin carries none: it
 ```bash
 mcpp build                                     # the backend, the mock mcpp, mcpp-ide-dev
 mcpp test                                      # the backend's tests
-cd mide-plugins/vscode && npm ci && npm test   # the extension's and the panels' tests
+cd mide-plugins/vscode && npm ci && npm test   # the extension's tests, the parity gates against 0.9.0 among them
+npm run test:webui                             # CLion's graph page in Chromium, over the backend
 npm run package                                # dist/mcpp-vscode-<version>.vsix
 cd ../clion && gradle buildPlugin verifyPlugin # build/distributions/mcpp-clion-<version>.zip
 cd ../.. && nvim --headless --clean -l mide-plugins/nvim/tests/smoke.lua   # the Neovim plugin's tests