M5: MXP + Pueblo parsers, emoji, clickable links, packaging

.github/workflows/ci.yml

@@ -28,21 +28,42 @@ jobs:
           dotnet-version: '10.0.x'
 
       - name: Restore
-        run: dotnet restore MuGlyph.slnx
+        run: dotnet restore SharpMUTerm.slnx
 
       - name: Build
-        run: dotnet build MuGlyph.slnx -c Release --no-restore
+        run: dotnet build SharpMUTerm.slnx -c Release --no-restore
 
       # TUnit runs on Microsoft.Testing.Platform; execute each test project directly
       # (the classic `dotnet test`/VSTest path is not used by MTP on .NET 10).
       - name: Test — Core
         shell: bash
-        run: dotnet run -c Release --no-build --project tests/MuClient.Core.Tests/MuClient.Core.Tests.csproj
+        run: dotnet run -c Release --no-build --project tests/SharpMUTerm.Core.Tests/SharpMUTerm.Core.Tests.csproj
 
       - name: Test — Graphics
         shell: bash
-        run: dotnet run -c Release --no-build --project tests/MuClient.Graphics.Tests/MuClient.Graphics.Tests.csproj
+        run: dotnet run -c Release --no-build --project tests/SharpMUTerm.Graphics.Tests/SharpMUTerm.Graphics.Tests.csproj
 
       - name: Test — Scripting
         shell: bash
-        run: dotnet run -c Release --no-build --project tests/MuClient.Scripting.Tests/MuClient.Scripting.Tests.csproj
+        run: dotnet run -c Release --no-build --project tests/SharpMUTerm.Scripting.Tests/SharpMUTerm.Scripting.Tests.csproj
+
+      - name: Test — Web
+        shell: bash
+        run: dotnet run -c Release --no-build --project tests/SharpMUTerm.Web.Tests/SharpMUTerm.Web.Tests.csproj
+
+      - name: Test — Tui
+        shell: bash
+        run: dotnet run -c Release --no-build --project tests/SharpMUTerm.Tui.Tests/SharpMUTerm.Tui.Tests.csproj
+
+      # End-to-end guard: the headless snapshot must render the workspace (rail, worlds, command
+      # surface) and exit — catches both UI-render regressions and any return of the stdin-block hang.
+      - name: Smoke — headless snapshot
+        shell: bash
+        run: |
+          dotnet run -c Release --no-build --project src/SharpMUTerm.Tui/SharpMUTerm.Tui.csproj -- \
+            --snapshot --size 120x30 --out snapshot.ans </dev/null
+          test -s snapshot.ans || { echo "snapshot produced no output"; exit 1; }
+          for token in CONNECTIONS Aetherfall Corvid palette; do
+            grep -qF "$token" snapshot.ans || { echo "snapshot missing token: $token"; exit 1; }
+          done
+          echo "headless snapshot smoke passed ($(wc -c < snapshot.ans) bytes)"

.github/workflows/release.yml

@@ -0,0 +1,76 @@
+name: Release
+
+on:
+  push:
+    tags: ['v*']
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  publish:
+    name: publish (${{ matrix.rid }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { os: ubuntu-latest, rid: linux-x64, profile: linux-x64 }
+          - { os: windows-latest, rid: win-x64, profile: win-x64 }
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Set up .NET 10 SDK
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: '10.0.x'
+
+      - name: Publish single-file
+        shell: bash
+        run: >
+          dotnet publish src/SharpMUTerm.Tui/SharpMUTerm.Tui.csproj
+          -p:PublishProfile=${{ matrix.profile }}
+          -o publish/${{ matrix.rid }}
+
+      - name: Package (Linux)
+        if: runner.os == 'Linux'
+        shell: bash
+        run: |
+          cd publish/${{ matrix.rid }}
+          tar -czf ../../sharpmuterm-${{ matrix.rid }}.tar.gz sharpmuterm
+
+      - name: Package (Windows)
+        if: runner.os == 'Windows'
+        shell: bash
+        run: |
+          cd publish/${{ matrix.rid }}
+          7z a ../../sharpmuterm-${{ matrix.rid }}.zip sharpmuterm.exe
+
+      - name: Upload build artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: sharpmuterm-${{ matrix.rid }}
+          path: sharpmuterm-${{ matrix.rid }}.*
+
+  # Serialize release creation in a single downstream job so the two matrix jobs don't race
+  # softprops/action-gh-release on the same tag.
+  release:
+    needs: publish
+    if: startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+          merge-multiple: true
+
+      - name: Create release and upload assets
+        uses: softprops/action-gh-release@v2
+        with:
+          files: artifacts/*

.gitignore

@@ -55,3 +55,8 @@ desktop.ini
 appsettings.*.local.json
 *.local.json
 secrets.json
+.claude/
+
+# Python bytecode cache
+__pycache__/
+*.pyc

CLAUDE.md

@@ -1,11 +1,11 @@
-# CLAUDE.md — MuGlyph agent brief
+# CLAUDE.md — SharpMUTerm agent brief
 
 Guidance for any Claude agent working in this repository. Read this first, then read
 [`docs/PLAN.md`](docs/PLAN.md) — the plan is the authoritative architecture + roadmap.
 
 ## What this project is
 
-**MuGlyph** is a cross-platform TUI **MU\*** (MUSH / MUCK / MUD) client in **C# / .NET 10**,
+**SharpMUTerm** is a cross-platform TUI **MU\*** (MUSH / MUCK / MUD) client in **C# / .NET 10**,
 targeting feature parity with [BeipMU](https://beipdev.github.io/BeipMU/), running inside
 GPU-accelerated terminals (Kitty, WezTerm, Ghostty) on **Windows and Linux**.
 
@@ -16,28 +16,37 @@ fallbacks) for inline images/maps.
 ## Locked decisions (do not relitigate without asking)
 
 - **Target framework:** `net10.0`.
-- **TUI base:** Terminal.Gui **v2** (prerelease) for windows/input/layout/scrollback, plus a
-  custom placeholder-based `GraphicsView` for images.
+- **TUI base:** **SharpConsoleUI** (`nickprotop/ConsoleEx`, stable, net8/9/10) — a compositor-based
+  framework with split layouts, tabs, resizable/mouse-draggable windows, Spectre-style markup, and
+  a **native Kitty graphics protocol** (+ Sixel/half-block) for inline images. Replaced Terminal.Gui
+  v2 (which was prerelease with an `[Obsolete]` mid-migration API); the switch is contained to
+  `SharpMUTerm.Tui` because `SharpMUTerm.Core` is UI-agnostic.
 - **Scripting:** Lua via **MoonSharp** (pure-managed, sandboxed).
 - **Inline graphics:** in scope from day one (Kitty Unicode placeholders → Sixel → half-block).
 - **Protocols:** aim for all common MU\* protocols. GMCP/MSSP/CHARSET/NAWS/MTTS/EOR via
   TelnetNegotiationCore; **MCCP, MSDP, MXP, and Pueblo are our own app layer.**
-- **Config:** fresh JSON schema of our own + a **BeipMU import/migration** path.
+- **Config:** fresh JSON schema of our own (worlds hold characters; automation lives in shared
+  named trigger sets), versioned with automatic migration between schema revisions.
 - **License:** MIT.
 
 ## Repository state
 
-**M1 delivered, plus substantial M2–M4 work.** `MuGlyph.slnx` builds all seven projects on
-`net10.0`; the solution has **195 passing tests**. In place:
+**M1 delivered, plus substantial M2–M4 work.** `SharpMUTerm.slnx` builds all ten projects on
+`net10.0`; the solution has **514 passing tests**. In place:
 
 - **Core** — `AnsiParser` (SGR 16/256/truecolor), styled-line + `ScrollbackBuffer` model,
   `TcpTransport` (TLS + IPv6), `TelnetSession` (wraps TelnetNegotiationCore **2.5.3**),
-  trigger/alias/macro engines + `IntervalScheduler`, plain-text + HTML logging, JSON config +
-  BeipMU importer, `Theme`/`ThemeLibrary`, and `WorldSession`/`SessionManager` orchestration.
+  trigger/alias/macro engines + `IntervalScheduler`, plain-text + HTML logging, versioned JSON
+  config (worlds → characters + shared trigger sets, with migration),
+  `Theme`/`ThemeLibrary`, and `WorldSession`/`SessionManager` orchestration.
 - **Graphics** — Kitty encoder + Unicode placeholders, Sixel + half-block fallbacks, capability
   probe (no UI dependency).
 - **Scripting** — sandboxed MoonSharp `ScriptHost` (world/output/trigger/alias/timer/gmcp/log).
-- **Tui** — Terminal.Gui v2 app (truecolor `OutputView`, `CommandInput`, theming, key routing).
+- **Tui** — **SharpConsoleUI** app: a `TabControl` of output windows (main + trigger-routed **spawn
+  windows** + web view, with unread badges), each a `MarkupControl` fed StyledLine → Spectre-style
+  markup via `MarkupFormatter` (clickable `[link=…]` MXP/Pueblo/web spans); a `PromptControl` input,
+  status line, `Ctrl+Q` quit, NAWS-on-resize. The tab/pane set is driven by the tested `Core.Workspaces`
+  model, with **splits** (thin single-line dividers) and the **connection rail** now rendered as well.
 
 ### Notes for future agents (learned the hard way)
 - **.NET 10 SDK**: install via `apt-get install -y dotnet-sdk-10.0` (the Microsoft CDN is often
@@ -49,49 +58,62 @@ fallbacks) for inline images/maps.
   provides MCCP/MSDP/MXP negotiation itself. `TelnetSession` sets the init-only
   `CallbackOnByteAsync` reflectively to get raw data bytes (incl. unterminated prompts) — a
   first-class `OnByte` builder hook is a good upstream PR.
-- **Terminal.Gui v2** (2.4.x-develop) dropped `Toplevel`/`TabView`; use `IRunnable`/`Window` and
-  override `OnDrawingContent(DrawContext)`. The static `Application` API is `[Obsolete]` mid-migration
-  (suppressed via `NoWarn` in the Tui project).
+- **SharpConsoleUI** (package `SharpConsoleUI`, repo `nickprotop/ConsoleEx`): app is
+  `ConsoleWindowSystem(new NetConsoleDriver(RenderMode.Buffer), new ConsoleWindowSystemOptions())`;
+  build windows/controls with the fluent `WindowBuilder`/`Controls` factories; `AddControl` is
+  builder-time (keep control refs and mutate at runtime). Marshal background work with
+  `system.EnqueueOnUIThread`; global keys via `RegisterGlobalShortcut`; `system.Run()` blocks the
+  loop, `RequestExit(code)` ends it. Text is Spectre-style markup (`[bold #rrggbb on #rrggbb]…[/]`,
+  `[[`/`]]` escaping, `[link=url]…[/]` → `MarkupControl.LinkClicked`). A **headless** sandbox can't
+  run `NetConsoleDriver` (no console) — the Tui is build-verified + unit-tested (`MarkupFormatter`);
+  visual verification is on the maintainer's machine.
 
 ## Architecture rule (non-negotiable)
 
-`MuClient.Core` stays **UI-agnostic and fully unit-testable**. All transport, telnet, parsing
+`SharpMUTerm.Core` stays **UI-agnostic and fully unit-testable**. All transport, telnet, parsing
 (ANSI/MXP/Pueblo), GMCP/MSDP routing, scrollback, and trigger/alias/macro engines live there.
-Terminal.Gui is referenced **only** from `MuClient.Tui`.
+SharpConsoleUI is referenced **only** from `SharpMUTerm.Tui`.
 
 Planned solution layout:
 
 | Project | Responsibility |
 |---|---|
-| `MuClient.Core` | Transport, telnet, ANSI/MXP/Pueblo parsers, GMCP/MSDP routing, scrollback, engines, logging (no UI deps) |
-| `MuClient.Graphics` | Kitty graphics protocol, capability probe, Sixel + half-block fallbacks, `GraphicsView` |
-| `MuClient.Scripting` | MoonSharp host + scripting API |
-| `MuClient.Tui` | Terminal.Gui v2 application |
-| `MuClient.Core.Tests`, `MuClient.Graphics.Tests` | xUnit |
+| `SharpMUTerm.Core` | Transport, telnet, ANSI/MXP/Pueblo parsers, GMCP/MSDP routing, scrollback, engines, logging (no UI deps) |
+| `SharpMUTerm.Graphics` | Kitty graphics protocol, capability probe, Sixel + half-block fallbacks, `GraphicsView` |
+| `SharpMUTerm.Scripting` | MoonSharp host + scripting API |
+| `SharpMUTerm.Tui` | SharpConsoleUI application |
+| `*.Tests` (Core, Graphics, Scripting, Web, Tui) | TUnit |
 
-## Milestone M1 — first task
+## Milestone M1 — first task (delivered)
 
-1. Create `MuGlyph.sln` with the four projects above targeting `net10.0`, plus the xUnit test projects.
+Kept for context; **M1 is done** (see *Repository state* above). As originally scoped:
+
+1. Create `SharpMUTerm.slnx` with the projects above targeting `net10.0`, plus the TUnit test projects.
 2. Add NuGet references (see version notes below).
 3. Runnable stub: connect over TCP (+ optional TLS via `SslStream`, IPv6-capable), pipe received
    bytes through a first-pass `AnsiParser` (SGR: 16 / 256 / 24-bit color), render colored output
-   in a Terminal.Gui window with an input line + history.
-4. Unit-test `AnsiParser` and the telnet-session wrapper in `MuClient.Core.Tests`.
+   in a SharpConsoleUI window with an input line + history.
+4. Unit-test `AnsiParser` and the telnet-session wrapper in `SharpMUTerm.Core.Tests`.
 
 ## Dependency notes / traps
 
 - **.NET 10 SDK** may need installing in the sandbox (currently RC, e.g. `10.0.100-rc.1`).
-- **Terminal.Gui v2 is a prerelease** — add with `dotnet add package Terminal.Gui --prerelease`.
-  v1 (stable) has a completely different API; do not use it.
-- **TelnetNegotiationCore 1.0.0** provides negotiation only (TELOPT, GA, TTYPE/MTTS, EOR, NAWS,
-  CHARSET, MSSP, GMCP). It does **not** provide MCCP, MSDP, MXP, Pueblo, or ANSI parsing — those
-  are our layer. Do not assume APIs for them exist. (Note: the repo owner authored this library,
-  so extending it directly is on the table — propose it via PR rather than assuming.)
+- **SharpConsoleUI** — stable release, multi-targets net8/9/10; MIT. Provides split layouts, tabs,
+  resizable/mouse windows, and native Kitty graphics, so the multi-pane workspace and inline images
+  ride on the framework rather than being hand-drawn.
+- **TelnetNegotiationCore 2.5.3** (the version in use) has a fluent builder API and now negotiates
+  MCCP/MSDP/MXP itself, on top of the base negotiation (TELOPT, GA, TTYPE/MTTS, EOR, NAWS, CHARSET,
+  MSSP, GMCP). **Pueblo and the ANSI/MXP/Pueblo _parsing_ remain our layer** — the library does the
+  option handshake, not the payload parsing. `TelnetSession` sets the init-only `CallbackOnByteAsync`
+  reflectively to see raw bytes (incl. unterminated prompts); a first-class `OnByte` builder hook is a
+  good upstream PR. (Note: the repo owner authored this library, so extending it directly is on the
+  table — propose it via PR rather than assuming.)
 - **MoonSharp** — package id `MoonSharp`, pure-managed, no native deps.
 
 ## Verification
 
-- Primary signal: `dotnet build` + `dotnet test`. Keep coverage in `MuClient.Core.Tests`
+- Primary signal: `dotnet build` + `dotnet run --project <testproj>` for each test project
+  (see the TUnit/MTP note above — `dotnet test` does **not** work here). Keep coverage in `SharpMUTerm.Core.Tests`
   (ANSI/SGR parser, telnet round-trips, engines).
 - A headless sandbox **cannot** visually verify a TUI and **cannot** render Kitty graphics.
   Treat the graphics layer as build-verified + capability-probed, never visually confirmed;

Directory.Build.props

@@ -1,6 +1,6 @@
 <Project>
 
-  <!-- Shared settings for every project in the MuGlyph solution. -->
+  <!-- Shared settings for every project in the SharpMUTerm solution. -->
   <PropertyGroup>
     <TargetFramework>net10.0</TargetFramework>
     <LangVersion>latest</LangVersion>
@@ -11,10 +11,10 @@
     <InvariantGlobalization>true</InvariantGlobalization>
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
     <Authors>Harry Cordewener</Authors>
-    <Product>MuGlyph</Product>
+    <Product>SharpMUTerm</Product>
     <Copyright>Copyright (c) 2026 Harry Cordewener</Copyright>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
-    <RepositoryUrl>https://github.com/HarryCordewener/MuGlyph</RepositoryUrl>
+    <RepositoryUrl>https://github.com/SharpMUSH/SharpMUTerm</RepositoryUrl>
   </PropertyGroup>
 
 </Project>

Directory.Packages.props

@@ -6,15 +6,18 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <!-- TUI toolkit (v2 is prerelease; API differs completely from v1). -->
-    <PackageVersion Include="Terminal.Gui" Version="2.4.18-develop.6" />
+    <!-- TUI framework: compositor, split layouts, tabs, mouse, Kitty graphics (stable, net10). -->
+    <PackageVersion Include="SharpConsoleUI" Version="2.5.14" />
 
     <!-- Telnet negotiation: TELOPT/NAWS/MTTS/EOR/CHARSET/MSSP/GMCP/MSDP/MCCP/MXP negotiation. -->
     <PackageVersion Include="TelnetNegotiationCore" Version="2.5.3" />
 
     <!-- Sandboxed Lua scripting (pure-managed, no native deps). -->
     <PackageVersion Include="MoonSharp" Version="2.0.0" />
 
+    <!-- Pure-managed HTML5 parser for the in-TUI web view. -->
+    <PackageVersion Include="AngleSharp" Version="1.6.0" />
+
     <!-- Logging abstractions (TelnetNegotiationCore takes an ILogger). -->
     <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.2" />