Configure Serena MCP and memories

- Add Serena project memories and Trae MCP server config\n- Fix sample BotEngine config keys: ReplyMode/ExecutionMode

Author: azhe403

.serena/memories/conventions.md

@@ -0,0 +1,17 @@
+- Commands:
+  - Implement as classes inheriting `BotCommandController`.
+  - Route by attributes on methods: `[Command]`, `[TextCommand]`, `[TypedCommand]`, `[UpdateCommand]`, `[InlineQuery]`, `[Callback]`, `[DefaultCommand]`.
+  - Controllers are constructed via `ActivatorUtilities.CreateInstance`; constructor DI is supported.
+  - Prefer using `Context` + controller helper wrappers (`SendMessage`, `AnswerCallbackQuery`, `AnswerInlineQuery`) instead of reaching into Telegram client directly.
+- Middleware:
+  - Implement `IBeforeCommand` and call `next(commandContext)` to pass; skipping it cancels command invocation.
+  - Implement `IAfterCommand` for post-invocation work.
+  - Disable middleware by annotating the class with `[DisabledMiddleware]` or listing its class name in `BotEngine.DisabledMiddleware`.
+- Configuration:
+  - Binding paths are `BotEngine` (`BotEngineConfig.ConfigPath`) and `BotEngine:Bot` (`BotTokenConfig.ConfigPath`).
+  - Important pitfall: sample `appsettings.Development.json` uses `ReplyStrategy`/`ExecutionStrategy`, but the model properties are `ReplyMode`/`ExecutionMode`.
+- Routing behavior (non-obvious):
+  - Message routing checks in order: `[Command]` -> `[TextCommand]` -> `[TypedCommand]` -> `[DefaultCommand]`.
+  - Inline query fallback: if no command match, falls back to any `[InlineQuery]`.
+  - Callback fallback: falls back to `[Callback]` with empty command.
+  - `ComparisonMode` enum has more values than currently implemented in router’s `TextCommand` switch.

.serena/memories/core.md

@@ -0,0 +1,17 @@
+- Repo: C#/.NET Telegram bot framework + sample host.
+- Solution: `ZiziBot.TelegramBot.sln` with 2 projects:
+  - Framework: `ZiziBot.TelegramBot.Framework/` (routing, middleware pipeline, polling/webhook engines)
+  - Sample: `ZiziBot.TelegramBot.Sample/` (ASP.NET Core minimal host using the framework)
+- Read these when working in each area:
+  - Framework architecture + entrypoints: `mem:framework/core`
+  - Sample host wiring + examples: `mem:sample/core`
+- Project-wide references:
+  - Toolchain + deps: `mem:tech_stack`
+  - Commands to build/run/pack: `mem:suggested_commands`
+  - Codebase conventions/pitfalls: `mem:conventions`
+  - “Done” checklist for tasks: `mem:task_completion`
+- Primary runtime invariants (framework):
+  - `AddZiziBotTelegramBot()` does assembly scanning for controllers + middleware and selects engine based on `BotEngine.EngineMode`.
+  - `UseZiziBotTelegramBot()` maps webhook endpoints (if `WebApplication`) and starts the selected `IBotEngine`.
+  - Each update is processed in an async DI scope via `BotEngineHandler` -> `BotUpdateHandler`.
+- Docs artifact: `CODE_WIKI.md` at repo root (human-facing, comprehensive).

.serena/memories/framework/core.md

@@ -0,0 +1,21 @@
+Framework module: `ZiziBot.TelegramBot.Framework/`.
+
+Entry points:
+- DI registration + engine selection: `Extensions/ClientExtension.AddZiziBotTelegramBot()`.
+- Host startup: `Extensions/ClientExtension.UseZiziBotTelegramBot()`.
+- Webhook mapping: `Extensions/EndpointExtension.StartWebhookModeInternal()` maps `/api/telegram-webhook/{botToken}`.
+
+Core flow:
+- `IBotEngine` implementation produces updates:
+  - Polling: `Engines/BotPollingEngine` uses `StartReceiving`.
+  - Webhook: `Engines/BotWebhookEngine` calls `SetWebhook` to `{WebhookUrl}/api/telegram-webhook/{botToken}`.
+- Updates are processed via `Handlers/BotEngineHandler` which creates an async DI scope per update and delegates to `Handlers/BotUpdateHandler`.
+- `BotEngineConfig.ExecutionMode` controls await vs fire-and-forget update handling.
+
+Routing + pipeline:
+- Router: `Handlers/BotUpdateHandler` matches methods by attributes and invokes them.
+- Before/after middleware resolved from DI (`IBeforeCommand`, `IAfterCommand`).
+- Context: `Models/CommandContext` provides strongly-typed accessors + Telegram response helpers.
+
+Known limitation:
+- `BotWebhookEngine.Stop(...)` is not implemented (throws).

.serena/memories/memory_maintenance.md

@@ -0,0 +1,33 @@
+# Memory Maintenance
+
+## Discovery Model
+
+- Core principle: progressive discovery through references, building a graph of memories.
+- Initially, agents are provided with the list of all memories (names only).
+- Agents should read `mem:core` as the top-level entry point (graph root).
+  This memory should contain references to other memories covering major project domains.
+  The referenced memories shall, in turn, shall contain references to even more specific memories, and so on.
+  The depth of the graph shall depend on the project complexity.
+- Use topics/folders to group related memories in order to make the content structure explicit.
+  Folders can mirror project structure (e.g. modules like frontend/backend) or topics like debugging, architecture, etc.
+- Memory references must use a mem: prefix inside backticks, e.g. `mem:frontend/core`.
+  The surrounding text should clearly indicate when to read the memory/which content to expect.
+  The text should provide more precise guidance than the memory name alone, 
+  i.e. avoid a reference like "frontend debugging: `mem:frontend/debugging` and instead make clear which aspects of frontend debugging are covered.
+- Memories themselves should not contain information about when to read them; this is the responsibility of the referring memory.
+
+## Style
+
+Dense agent notes, not prose docs. Prefer invariants, terse bullets. 
+Avoid obvious context, rationale, and examples unless they prevent likely mistakes. 
+Keep guidance durable and generalizable, not task-local.
+
+## Add/update threshold
+
+Add or update memories only with stable, non-obvious project conventions that avoid complex rediscovery in the future.
+Do not add: quick-read facts; generic language/framework knowledge; one-off task notes; volatile line-level details; behavior likely to change soon.
+
+## Maintenance Actions
+
+- Renaming memories: References are updated automatically if handled via Serena's memory rename tool.
+- Checking for stale memories (e.g. after deletion): Call `serena memories check` for a report.

.serena/memories/sample/core.md

@@ -0,0 +1,18 @@
+Sample module: `ZiziBot.TelegramBot.Sample/` (ASP.NET Core minimal host).
+
+Startup:
+- `Program.cs` wires logging (Serilog), then calls `AddZiziBotTelegramBot()` and `UseZiziBotTelegramBot()`.
+- Exposes `GET /` => `OK!`.
+
+Examples:
+- Commands in `Commands/` show:
+  - Message commands via `[Command]` and `[TextCommand]`.
+  - Default command via `[DefaultCommand]`.
+  - Inline queries via `[InlineQuery]`.
+  - Callback queries via `[Callback]`.
+  - Non-message events via `[TypedCommand]` and `[UpdateCommand]`.
+- Middleware in `Middlewares/` show `IBeforeCommand`/`IAfterCommand` and disabling via `[DisabledMiddleware]` and `BotEngine.DisabledMiddleware`.
+
+Config:
+- `appsettings.Development.json` contains `BotEngine` section with `EngineMode`, `WebhookUrl`, `DisabledMiddleware`, and bot tokens (`Bot`).
+- Align `ReplyStrategy`/`ExecutionStrategy` keys to `ReplyMode`/`ExecutionMode` if you want binding to work automatically.

.serena/memories/suggested_commands.md

@@ -0,0 +1,9 @@
+- Build (repo root): `dotnet build` (or `dotnet build -c Release`).
+- Run sample host:
+  - `cd ZiziBot.TelegramBot.Sample`
+  - `dotnet run`
+- Pack (NuGet package for framework, repo root): `dotnet pack -c Release`.
+- CI parity (publish workflow): `dotnet restore` -> `dotnet build -c Release` -> `dotnet pack -c Release`.
+- No test projects currently; if added later: `dotnet test` at repo root.
+- Troubleshooting SDK mismatch:
+  - Ensure .NET 10 SDK installed for the sample (`net10.0`).

.serena/memories/task_completion.md

@@ -0,0 +1,6 @@
+For typical code changes:
+- `dotnet build -c Release` at repo root.
+- If changes touch runtime behavior, run sample:
+  - set valid tokens in `ZiziBot.TelegramBot.Sample/appsettings.Development.json`
+  - `cd ZiziBot.TelegramBot.Sample && dotnet run`
+- No linters/formatters/test runners configured beyond `dotnet build` (no test projects in repo).

.serena/memories/tech_stack.md

@@ -0,0 +1,13 @@
+- Language: C# (nullable enabled), modern syntax (primary constructors used in core handlers/engines).
+- Build: `dotnet` (solution file), multi-target framework library.
+- Target frameworks:
+  - Framework: `net8.0;net9.0;net10.0` (`ZiziBot.TelegramBot.Framework.csproj`)
+  - Sample: `net10.0` (`ZiziBot.TelegramBot.Sample.csproj`)
+- Hosting: ASP.NET Core (Minimal APIs), `Microsoft.AspNetCore.App` framework reference in library.
+- Telegram integration:
+  - NuGet ref: `WTelegramBot` (code uses `Telegram.Bot.*` API surface).
+- DI scanning: `Scrutor` (registers `IBeforeCommand`/`IAfterCommand`).
+- IDs/tracing: `UUIDNext` for `CommandContext.SessionId`.
+- Logging:
+  - Framework uses `Microsoft.Extensions.Logging` abstractions.
+  - Sample config uses `Serilog.AspNetCore`.

.trae/mcp.json

@@ -0,0 +1,12 @@
+{
+    "mcpServers": {
+        "serena": {
+            "command": "serena",
+            "args": [
+                "start-mcp-server",
+                "--context=copilot-cli",
+                "--project=${workspaceFolder}"
+            ]
+        }
+    }
+}

ZiziBot.TelegramBot.Sample/appsettings.Development.json

@@ -8,8 +8,8 @@
   "BotEngine": {
     "WebhookUrl": "https://your-webhook-url.my.id",
     "EngineMode": "Auto",
-    "ReplyStrategy": "ReplyToSender",
-    "ExecutionStrategy": "Background",
+    "ReplyMode": "ReplyToSender",
+    "ExecutionMode": "Background",
     "DisabledMiddleware": [
       "ClassNameOfMiddlewareHere",
       "SampleDisabledClassBeforeMiddleware"
@@ -25,4 +25,4 @@
       }
     ]
   }
-}
+}