Reorganise by feature, rename to Novelly, add Aspire and a pre-push hook

The layered split into Domain/Application/Infrastructure/Api was forcing
organisation by layer: adding one capability meant touching four projects and
four folders that each held a slice of it. Those four projects are now one
feature-organised Novelly.Api, where each folder — Projects, Characters,
Chapters, Beats, Scenes, Tags, Agent — holds its entity, DTOs, service and
endpoints together. Common/ holds what genuinely crosses features (the patch
semantics, the two exception types, DraftStatus) and Data/ holds the DbContext
and migrations.

Six .NET projects become five: the three layer projects are gone, and
Novelly.AppHost and Novelly.ServiceDefaults are new.

- Namespaces move from NovelSoftware.* to Novelly.*, including the entity type
  names recorded in the EF model snapshots. The migration ids are untouched, so
  an existing novel.db still migrates cleanly — verified against a fresh file.
- Aspire orchestration mirrors the mic-check setup: the AppHost starts the API
  on :5080 and the Vite dev server on :5173, and the API picks up OpenTelemetry,
  health checks and service discovery from ServiceDefaults. /health and /alive
  now answer in development.
- A Husky pre-push hook runs scripts/ci/prepush.sh: build, test, then a web
  build. The scripts are plain bash so CI can run the same steps.
- The MCP server's env var is now NOVELLY_API_URL.

Verified beyond the build: 44 tests pass, the web client builds, the API was
exercised over curl (project/chapter/beat/tag round trip, tag cross-reference,
503 on the agent without a key while conversation listing still returns 200),
the MCP server was driven over stdio JSON-RPC (26 tools, errors still surface
the API's own message rather than being flattened), and the AppHost was run to
confirm both resources come up and Vite proxies /api through to the API.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01S56bfZMGe1hnhpWP4CjjNw

src/Novelly.Mcp/NovelApiClient.cs

@@ -0,0 +1,104 @@
+using System.Net;
+using System.Net.Http.Json;
+using System.Text.Json;
+using ModelContextProtocol.Protocol;
+
+namespace Novelly.Mcp;
+
+/// <summary>
+/// Thin wrapper over the Novelly REST API. The MCP server deliberately owns no
+/// domain logic of its own — it is a second front end onto the same API the web client
+/// uses, so an edit made from Claude Code and one made in the browser are the same edit.
+/// </summary>
+public class NovelApiClient(HttpClient http)
+{
+    private static readonly JsonSerializerOptions Options = new(JsonSerializerDefaults.Web)
+    {
+        WriteIndented = true
+    };
+
+    public Task<CallToolResult> GetAsync(string path, CancellationToken ct = default) =>
+        SendAsync(new HttpRequestMessage(HttpMethod.Get, path), ct);
+
+    public Task<CallToolResult> PostAsync(string path, object body, CancellationToken ct = default) =>
+        SendAsync(new HttpRequestMessage(HttpMethod.Post, path)
+        {
+            Content = JsonContent.Create(body, options: Options)
+        }, ct);
+
+    public Task<CallToolResult> PatchAsync(string path, object body, CancellationToken ct = default) =>
+        SendAsync(new HttpRequestMessage(HttpMethod.Patch, path)
+        {
+            Content = JsonContent.Create(body, options: Options)
+        }, ct);
+
+    public Task<CallToolResult> DeleteAsync(string path, CancellationToken ct = default) =>
+        SendAsync(new HttpRequestMessage(HttpMethod.Delete, path), ct);
+
+    /// <summary>
+    /// Sends the request and shapes the outcome as a tool result. Failures come back as
+    /// `isError` results carrying the API's own message, rather than as exceptions the
+    /// SDK would flatten into "an error occurred" — the model can act on the former.
+    /// </summary>
+    private async Task<CallToolResult> SendAsync(HttpRequestMessage request, CancellationToken ct)
+    {
+        HttpResponseMessage response;
+        try
+        {
+            response = await http.SendAsync(request, ct);
+        }
+        catch (HttpRequestException ex)
+        {
+            // The API not being up is the most common failure here, and a bare connection
+            // exception tells the model nothing actionable.
+            return Error($"Could not reach the Novelly API at {http.BaseAddress}. Is it running? ({ex.Message})");
+        }
+
+        var body = await response.Content.ReadAsStringAsync(ct);
+
+        if (response.IsSuccessStatusCode)
+        {
+            return Ok(string.IsNullOrWhiteSpace(body) ? "{\"ok\":true}" : Prettify(body));
+        }
+
+        var detail = TryReadProblemDetail(body) ?? body;
+        return Error(response.StatusCode switch
+        {
+            HttpStatusCode.NotFound => $"Not found: {detail}",
+            HttpStatusCode.BadRequest => $"Rejected: {detail}",
+            _ => $"API returned {(int)response.StatusCode}: {detail}"
+        });
+    }
+
+    private static CallToolResult Ok(string text) =>
+        new() { Content = [new TextContentBlock { Text = text }] };
+
+    private static CallToolResult Error(string message) =>
+        new() { Content = [new TextContentBlock { Text = message }], IsError = true };
+
+    /// <summary>Reformats the API's compact JSON so tool output reads well in a transcript.</summary>
+    private static string Prettify(string json)
+    {
+        try
+        {
+            return JsonSerializer.Serialize(JsonSerializer.Deserialize<JsonElement>(json), Options);
+        }
+        catch (JsonException)
+        {
+            return json;
+        }
+    }
+
+    private static string? TryReadProblemDetail(string body)
+    {
+        try
+        {
+            var problem = JsonSerializer.Deserialize<JsonElement>(body);
+            return problem.TryGetProperty("detail", out var detail) ? detail.GetString() : null;
+        }
+        catch (JsonException)
+        {
+            return null;
+        }
+    }
+}