Read the whole
conversation.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <RootNamespace>LilithConsole</RootNamespace>
  </PropertyGroup>

  <ItemGroup>
    <ProjectReference Include="..\..\..\Lilith\Agent\Agent.csproj" />
  </ItemGroup>

</Project>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

using System;
using System.Text;
using System.Threading.Tasks;
using Lilith.Core.Logging;
using Lilith.Agent;
using LilithAgent = Lilith.Agent;
using LilithConsole.Setup;
using Lilith.Core.Kokoro;

namespace LilithConsole
{
    partial class Program
    {
        static async Task Main(string[] args)
        {
            Console.OutputEncoding = Encoding.UTF8;
            var consoleSink = new TextLogSink(Console.Out, overwriteProgress: !Console.IsOutputRedirected,
                width: () => Math.Max(Console.WindowWidth - 1, 1));
            Action<LogEntry> onLog = consoleSink.Handle;

            var logger = new Logger(onLog);
            try
            {
                string settingsPath = Environment.GetEnvironmentVariable("LILITH_CONSOLE_SETTINGS")
                    ?? System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Lilith", "console-settings.json");
                var credentials = await ProviderSetup.RunAsync(Console.In, Console.Out, logger, settingsPath);
                if (credentials is null) { logger.SystemWriteLine("Setup stopped. Relaunch to continue."); return; }
                if (!Console.IsInputRedirected || Environment.GetEnvironmentVariable("LILITH_TTS") == "1")
                {
                    try
                    {
                        credentials = credentials with { Tts = await KokoroSetup.RunAsync(Console.In, Console.Out,
                            logger, settingsPath + ".kokoro.json") };
                    }
                    catch (Exception ex) { logger.SystemWriteLine($"Speech setup failed: {ex.Message}. Relaunch to retry; continuing with text chat.", LogColors.Orange); }
                }
                Console.Title = $"{credentials.AgentName} — {credentials.Model} Chat";
                await using var lilith = new LilithAgent.Lilith(onLog, credentials);
                string mode = "ask";
                if (!Console.IsInputRedirected)
                {
                    Console.Write("Workspace and scheduling mode for this boot [ask/yolo, default ask]: ");
                    mode = Console.ReadLine()?.Trim().ToLowerInvariant() ?? "ask";
                    if (mode.Length == 0) mode = "ask";
                    if (mode is not ("ask" or "yolo")) throw new ArgumentException("Choose ask or yolo at boot.");
                }
                else if (args.Contains("--workspace-yolo")) mode = "yolo";
                var workspace = Lilith.Core.Workspace.WorkspaceOptions.Default;
                string? workspaceRoot = Environment.GetEnvironmentVariable("LILITH_WORKSPACE_ROOT");
                lilith.WorkspaceOptions = workspace with { RootDirectory = workspaceRoot ?? workspace.RootDirectory,
                    Mode = mode == "yolo" ? Lilith.Core.Workspace.WorkspaceAccessMode.Yolo : Lilith.Core.Workspace.WorkspaceAccessMode.Ask };
                Console.WriteLine($"Workspace: {lilith.WorkspaceOptions.RootDirectory} ({mode}, fixed until restart). Use /workspace, /workspace review <id>, /approve <id>, /reject <id>.");
                await lilith.BootAsync(startServerIfNotRunning: true);

                while (true)
                {
                    Console.Title = $"{lilith.Personality.Name} — {credentials.Model} Chat";
                    string? input;
                    using (consoleSink.BeginInput())
                    {
                        lilith.Logger.Write("Input", "You: ", LogColors.Green);
                        input = Console.ReadLine()?.Trim();
                    }
                    if (input is null) break;
                    if (string.IsNullOrEmpty(input)) continue;
                    if (input.Equals("exit", StringComparison.OrdinalIgnoreCase)) break;
                    try
                    {
                        var command = await lilith.ChatCommands.ExecuteAsync(input);
                        if (command.Output is { Length: > 0 }) Console.WriteLine(command.Output);
                        if (command.ExitRequested) break;
                        if (!command.Handled) await lilith.ChatAsync(input);
                    }
                    catch (Exception ex)
                    {
                        lilith.Logger.SystemWriteLine($"Request failed: {ex.Message}. Please try again.", LogColors.Red);
                    }
                }
                await lilith.StopSchedulingAsync();
                lilith.SaveConversation();
                lilith.Logger.SystemWriteLine("Goodbye.");
            }
            catch (Exception ex)
            {
                logger.SystemWriteLine($"Setup/chat failed: {ex.Message}. Relaunch to retry; completed setup steps are retained.", LogColors.Red);
                Environment.ExitCode = 1;
            }
            finally { consoleSink.Flush(); }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

using System.Text.Json;
using System.Text.RegularExpressions;
using Lilith.Core.Logging;
using Lilith.Core.Ollama;
using Lilith.Core.Extensions;
using Lilith.Agent;

namespace LilithConsole.Setup;

public record ConsoleSettings(string? AgentName = null, string? Model = null)
{
    public bool IsValid() => (AgentName is null || (!string.IsNullOrWhiteSpace(AgentName) && AgentName.Length <= 80 && !AgentName.Any(char.IsControl))) &&
        (Model is null || (Model.Length <= 200 && RegexPatterns.ModelIdentifier().IsMatch(Model)));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

using System.Text.Json;
using System.Text.RegularExpressions;
using Lilith.Core.Logging;
using Lilith.Core.Ollama;
using Lilith.Core.Extensions;
using Lilith.Agent;

namespace LilithConsole.Setup;

/// <summary>Checks actual installation/model state on every launch, independent of saved preferences.</summary>
public sealed class ConsoleSetup(TextReader input, TextWriter output, ISetupServices services, Logger logger, string settingsPath)
{
    public static readonly IReadOnlyList<string> Models = Array.AsReadOnly<string>(["gemma4", "llama3.2", "qwen3:4b", "phi4-mini"]);

    public async Task<LilithCredentials?> RunAsync()
    {
        using var totalTimer = new ConsoleSetupTimer(logger);
        bool installed = await logger.TimeStageAsync("Installation check", () => Task.FromResult(services.IsInstalled()));
        if (!installed)
        {
            if (!await logger.TimeStageAsync("Installation choice", () => Task.FromResult(Confirm("Would you like to download and install Ollama? [y/N, exit]: ")))) return null;
            await logger.TimeStageAsync("Ollama installation", services.InstallAsync);
            if (!services.IsInstalled()) throw new InvalidOperationException("Ollama executable was not found after installation.");
        }
        else output.WriteLine("Ollama already installed; skipping installation.");
        await logger.TimeStageAsync("Server startup/check", services.EnsureServerAsync);

        ConsoleSettings settings = await logger.TimeStageAsync("Preferences load", () => Task.FromResult(Load()));
        if (settings.AgentName is null)
        {
            output.Write("Agent name (Enter for Lilith, /exit to leave): ");
            string? name = await logger.TimeStageAsync("Agent name selection", () => Task.FromResult(input.ReadLine()));
            if (name is null || name.Trim().Equals("/exit", StringComparison.OrdinalIgnoreCase)) return null;
            name = name.Trim();
            if (name.Length > 80 || name.Any(char.IsControl)) throw new ArgumentException("Agent name must be at most 80 characters without control characters.");
            settings = settings with { AgentName = name.Length == 0 ? "Lilith" : name };
            Save(settings); // Persist identity even if the application closes before a model is ready.
        }
        output.WriteLine($"Agent name: {settings.AgentName}");
        string? overrideModel = Environment.GetEnvironmentVariable("LILITH_MODEL");
        if (!string.IsNullOrWhiteSpace(overrideModel)) settings = settings with { Model = overrideModel.Trim() };

        bool available = settings.Model is not null &&
            await logger.TimeStageAsync("Saved model check", () => services.HasModelAsync(settings.Model));
        if (!available)
        {
            if (settings.Model is not null) output.WriteLine($"Model '{settings.Model}' is not installed. Choose a model to continue.");
            string? selected = await logger.TimeStageAsync("Model selection", () => Task.FromResult(SelectModel()));
            if (selected is null) return null;
            settings = settings with { Model = selected };
            Save(settings); // Remember selection even if a download is interrupted.
            available = await logger.TimeStageAsync("Selected model check", () => services.HasModelAsync(selected));
            if (!available)
            {
                if (!await logger.TimeStageAsync("Download choice", () => Task.FromResult(Confirm($"Download model '{selected}'? [y/N, exit]: ")))) return null;
                await logger.TimeStageAsync("Model download", () => services.DownloadAsync(selected));
                if (!await logger.TimeStageAsync("Downloaded model validation", () => services.HasModelAsync(selected)))
                    throw new InvalidOperationException("Model is still unavailable after download. Relaunch setup to retry.");
            }
            else output.WriteLine($"Model '{selected}' already installed; skipping download.");
        }
        else output.WriteLine($"Model '{settings.Model}' already installed; skipping selection and download.");
        Save(settings);
        totalTimer.Completed = true;
        return new LilithCredentials(settings.Model!,
            $"You are {settings.AgentName}, a helpful AI assistant. Greet the user warmly when the conversation begins.", settings.AgentName!);
    }

    private string? SelectModel()
    {
        while (true)
        {
            output.WriteLine("Choose a model:");
            for (int i = 0; i < Models.Count; i++) output.WriteLine($"{i + 1}. {Models[i]}");
            output.WriteLine("5. Custom model\n0. Exit");
            output.Write("Selection: ");
            string? selection = input.ReadLine()?.Trim();
            if (selection is null || selection.Equals("exit", StringComparison.OrdinalIgnoreCase) || selection == "0") return null;
            if (int.TryParse(selection, out int index) && index is >= 1 and <= 4) return Models[index - 1];
            if (selection == "5")
            {
                output.Write("Custom model name/tag (or exit): ");
                string? custom = input.ReadLine()?.Trim();
                if (custom is null || custom.Equals("exit", StringComparison.OrdinalIgnoreCase)) return null;
                if (custom.Length <= 200 && RegexPatterns.OllamaModelIdentifier().IsMatch(custom)) return custom;
                output.WriteLine("Enter a valid model name, for example llama3.2:1b.");
            }
            else output.WriteLine("Choose 1–5, or 0 to exit.");
        }
    }

    private bool Confirm(string question)
    {
        while (true)
        {
            output.Write(question);
            string? answer = input.ReadLine()?.Trim().ToLowerInvariant();
            if (answer is null or "" or "n" or "no" or "exit" or "0") return false;
            if (answer is "y" or "yes") return true;
            output.WriteLine("Please enter y, n, or exit.");
        }
    }

    private ConsoleSettings Load()
    {
        if (!File.Exists(settingsPath)) return new();
        try
        {
            return JsonSettings.Load<ConsoleSettings>(settingsPath, settings => settings.IsValid());
        }
        catch (JsonException ex) { output.WriteLine($"Saved settings could not be read ({ex.Message}); setup will ask again."); return new(); }
    }

    private void Save(ConsoleSettings settings)
    {
        JsonSettings.Save(settingsPath, settings);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

using System.Text.Json;
using System.Text.RegularExpressions;
using Lilith.Core.Logging;
using Lilith.Core.Ollama;
using Lilith.Core.Extensions;
using Lilith.Agent;

namespace LilithConsole.Setup;

internal sealed class ConsoleSetupTimer(Logger logger) : IDisposable
{
    private readonly System.Diagnostics.Stopwatch _timer = System.Diagnostics.Stopwatch.StartNew();
    public bool Completed { get; set; }
    public void Dispose()
    {
        _timer.Stop();
        logger.WriteLine("Boot", $"Console setup {(Completed ? "finished" : "stopped")} — elapsed {_timer.Elapsed.TotalSeconds:F2}s", LogColors.Gray);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

using System.Text.Json;
using System.Text.RegularExpressions;
using Lilith.Core.Logging;
using Lilith.Core.Ollama;
using Lilith.Core.Extensions;
using Lilith.Agent;

namespace LilithConsole.Setup;

public interface ISetupServices
{
    bool IsInstalled();
    Task InstallAsync();
    Task EnsureServerAsync();
    Task<bool> HasModelAsync(string model);
    Task DownloadAsync(string model);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

using System.Text.Json;
using System.Text.RegularExpressions;
using Lilith.Core.Logging;
using Lilith.Core.Ollama;
using Lilith.Core.Extensions;
using Lilith.Agent;

namespace LilithConsole.Setup;

public sealed class OllamaSetupServices(Logger logger) : ISetupServices
{
    public bool IsInstalled() => OllamaClient.IsOllamaInstalled();
    public Task InstallAsync() => OllamaClient.InstallAsync(logger);
    public Task EnsureServerAsync() => OllamaClient.EnsureServerAsync(logger);
    public Task<bool> HasModelAsync(string model) => OllamaClient.IsModelAvailableAsync(model);
    public Task DownloadAsync(string model) => OllamaClient.DownloadModelAsync(model, logger);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

using System.Text.Json;
using System.Text.RegularExpressions;
using Lilith.Agent;
using Lilith.Core.LMStudio;
using Lilith.Core.Logging;
using Lilith.Core.Extensions;

namespace LilithConsole.Setup;

public static class ProviderSetup
{
    public static async Task<LilithCredentials?> RunAsync(TextReader input, TextWriter output, Logger logger, string settingsPath)
    {
        string? selected = Environment.GetEnvironmentVariable("LILITH_PROVIDER");
        if (string.IsNullOrWhiteSpace(selected))
        {
            output.WriteLine("Choose your provider: 1. Ollama  2. LM Studio (Windows GUI)  0. Exit");
            output.Write("Provider [1]: ");
            selected = input.ReadLine()?.Trim();
            if (selected is null or "0" || selected.Equals("exit", StringComparison.OrdinalIgnoreCase)) return null;
            if (selected == "") selected = "1";
        }
        if (selected is "1" || selected.Equals("Ollama", StringComparison.OrdinalIgnoreCase))
            return await new ConsoleSetup(input, output, new OllamaSetupServices(logger), logger, settingsPath).RunAsync();
        if (selected != "2" && !selected.Equals("LMStudio", StringComparison.OrdinalIgnoreCase))
            throw new ArgumentException("Select 1/Ollama or 2/LMStudio.");

        string path = settingsPath + ".lmstudio.json";
        ConsoleSettings preferences = new();
        if (File.Exists(path))
        {
            try { preferences = JsonSettings.Load<ConsoleSettings>(path, settings => settings.IsValid()); }
            catch (JsonException) { output.WriteLine("Saved LM Studio preferences are invalid; choose them again."); }
        }
        if (!LMStudioSetup.IsInstalled())
        {
            output.Write("Download and install the LM Studio Windows GUI? [y/N]: ");
            string? answer = input.ReadLine()?.Trim();
            if (!string.Equals(answer, "y", StringComparison.OrdinalIgnoreCase) && !string.Equals(answer, "yes", StringComparison.OrdinalIgnoreCase)) return null;
            await LMStudioSetup.InstallGuiAsync(logger);
        }
        await LMStudioSetup.EnsureServerAsync(logger);
        if (preferences.AgentName is null)
        {
            output.Write("Agent name [Lilith]: ");
            string? name = input.ReadLine()?.Trim();
            if (name is null || name.Equals("/exit", StringComparison.OrdinalIgnoreCase)) return null;
            if (name.Length > 80 || name.Any(char.IsControl)) throw new ArgumentException("Invalid agent name.");
            preferences = preferences with { AgentName = name.Length == 0 ? "Lilith" : name };
        }
        void Save() => JsonSettings.Save(path, preferences);
        Save();
        var models = await LMStudioSetup.ListModelsAsync();
        if (preferences.Model is null || !models.Any(m => m.Id == preferences.Model))
        {
            output.WriteLine("Downloaded LM Studio models:");
            for (int i = 0; i < models.Count; i++) output.WriteLine($"{i + 1}. {models[i].Name} ({models[i].Id})");
            output.Write("Choose a number or enter a catalog ID (e.g. ibm/granite-4-micro); 0 exits: ");
            string? model = input.ReadLine()?.Trim();
            if (model is null or "0" || model.Equals("exit", StringComparison.OrdinalIgnoreCase)) return null;
            if (int.TryParse(model, out int index))
            {
                if (index < 1 || index > models.Count) throw new ArgumentException("Invalid model number.");
                model = models[index - 1].Id;
            }
            if (model.Length > 200 || !RegexPatterns.ModelIdentifier().IsMatch(model)) throw new ArgumentException("Invalid LM Studio model identifier.");
            preferences = preferences with { Model = model };
            Save();
            if (!models.Any(m => m.Id == model))
            {
                output.Write($"Download LM Studio model '{model}'? [y/N]: ");
                string? answer = input.ReadLine()?.Trim();
                if (!string.Equals(answer, "y", StringComparison.OrdinalIgnoreCase) && !string.Equals(answer, "yes", StringComparison.OrdinalIgnoreCase)) return null;
                await LMStudioSetup.DownloadModelAsync(model, logger);
            }
        }
        return new LilithCredentials(preferences.Model!,
            $"You are {preferences.AgentName}, a helpful AI assistant. Greet the user warmly when the conversation begins.",
            preferences.AgentName!, Lilith.Core.Providers.ProviderKind.LMStudio);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

using System.Text.Json;
using Lilith.Core.Commands;

namespace Lilith.Core.Calendar;

public static class CalendarCommands
{
    public static void Register(ChatCommandRegistry commands, Func<ProviderClient> provider)
    {
        commands.Register("calendar", "Show today's agenda; pending; review <proposal-id>.", c =>
        {
            var calendar = provider().Calendar ?? throw new InvalidOperationException("Calendar unavailable.");
            return c.Arguments switch
            {
                "" => calendar.Execute(new("agenda")).ToReply(),
                "pending" => calendar.Execute(new("pending")).ToReply(),
                var value when value.StartsWith("review ", StringComparison.Ordinal) => JsonSerializer.Serialize(calendar.Review(value[7..].Trim())),
                _ => throw new ArgumentException("Use /calendar, /calendar pending or /calendar review <id>.")
            };
        });
        commands.Register("calendar-approve", "Approve one exact prepared calendar change.", c => provider().ApproveCalendar(c.Arguments));
        commands.Register("calendar-reject", "Reject one prepared calendar change.", c => { provider().RejectCalendar(c.Arguments); return "Calendar proposal rejected."; });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

namespace Lilith.Core.Calendar;

public static class CalendarDelivery
{
    // Caller owns the host's conversation/narration gate, shared with scheduler delivery.
    public static async Task DrainAsync(ProviderClient provider, Func<string, CancellationToken, Task> narrate, CancellationToken ct = default)
    {
        if (provider.Calendar is not { } calendar) return;
        for (int i = 0; i < 10 && calendar.PeekNotice() is { } notice; i++)
        {
            ct.ThrowIfCancellationRequested();
            provider.RecordCalendarNotice(notice);
            await narrate(notice.Message, ct);
            calendar.CompleteNotice(notice.Id);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

using System.Text.Json;
using Lilith.Core.Workspace;

namespace Lilith.Core.Calendar;

public sealed record CalendarOptions(string RootDirectory, WorkspaceAccessMode Mode = WorkspaceAccessMode.Ask);
public sealed record CalendarRequest(string Operation, string Id = "", string Title = "", string Date = "",
    string Time = "", string TimeZone = "", string Reminder = "", string Notes = "", string Source = "", string Query = "");
public sealed record CalendarEntry(string Id, string Title, string Date, string Time, string TimeZone,
    DateTimeOffset? StartsUtc, DateTimeOffset? ReminderUtc, string Notes, string Source, int Revision, bool ReminderQueued = false);
public sealed record CalendarProposal(string Id, CalendarRequest Request, int? ExpectedRevision);
public sealed record CalendarNotice(string Id, string EventId, string Title, DateTimeOffset DueUtc, bool Missed, string Message);
public sealed record CalendarResult(string Status, string Message, object? Data = null, string? ProposalId = null)
{
    public string ToReply() => Status == "needs_approval"
        ? $"{Message}\nUse /calendar pending to review the prepared change, then /calendar-approve or /calendar-reject with its proposal ID."
        : Status == "completed" && EventData() is { } entry
            ? $"{Message} {entry.Title}: {entry.Date}{(entry.Time.Length == 0 ? " (all day)" : " at " + entry.Time + " " + entry.TimeZone)}. " +
              (entry.ReminderUtc is { } reminder ? $"Reminder: {TimeZoneInfo.ConvertTime(reminder, TimeZoneInfo.FindSystemTimeZoneById(entry.TimeZone)):yyyy-MM-dd HH:mm} {entry.TimeZone}." : "No reminder set.")
        : Status == "completed" && Data is null ? Message : JsonSerializer.Serialize(this);
    private CalendarEntry? EventData() => Data switch
    {
        CalendarEntry entry => entry,
        JsonElement { ValueKind: JsonValueKind.Object } element when element.TryGetProperty("Title", out _) => element.Deserialize<CalendarEntry>(),
        _ => null
    };
}
internal sealed class CalendarState
{
    public List<CalendarEntry> Entries { get; set; } = [];
    public List<CalendarProposal> Pending { get; set; } = [];
    public List<CalendarNotice> Notices { get; set; } = [];
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

using System.Text.Json;
using System.Text.RegularExpressions;

namespace Lilith.Core.Calendar;

internal static class CalendarOperations
{
    internal static readonly string[] Names = ["calendar_create_operation", "calendar_update_operation", "calendar_delete_operation", "calendar_read_operation", "calendar_search_operation", "calendar_agenda_operation", "calendar_offer_operation"];
    internal static bool Mutates(string name) => name is "calendar_create_operation" or "calendar_update_operation" or "calendar_delete_operation";
    internal static string Execute(ProviderClient owner, string name, IReadOnlyDictionary<string, string> inputs)
    {
        string Get(string key) => inputs.GetValueOrDefault(key) ?? "";
        if (name == "calendar_offer_operation")
        {
            string answer = Get("answer");
            return owner.Calendar is not null && Regex.IsMatch(Get("question"), @"\b(when|release|date|launch)\b", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)
                ? answer + "\n\nWould you like me to add this to your calendar? If so, what reminder date and time would you like, or would you prefer no reminder?" : answer;
        }
        var calendar = owner.Calendar ?? throw new InvalidOperationException("Calendar is not configured.");
        if (!Names.Contains(name)) throw new ArgumentException("Unknown calendar operation.");
        string operation = name[9..^10];
        return JsonSerializer.Serialize(calendar.Execute(new(operation, Get("id"), Get("title"), Get("date"), Get("time"), Get("timezone"), Get("reminder"), Get("notes"), Get("source"), Get("query"))));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

using System.Globalization;
using System.Text.Json;
using Lilith.Core.Workspace;
using Lilith.Core.Workspace.Extensions;

namespace Lilith.Core.Calendar;

/// <summary>Single-host calendar; detection persists notices without invoking a conversation.</summary>
public sealed class CalendarSession : IDisposable
{
    private readonly object _sync = new();
    private readonly FileStream _lease;
    private readonly string _file;
    private readonly TimeProvider _clock;
    private CalendarState _state;
    private bool _faulted, _disposed;
    public CalendarOptions Options { get; }

    public CalendarSession(CalendarOptions options, TimeProvider? clock = null)
    {
        if (!Enum.IsDefined(options.Mode)) throw new ArgumentException("Unknown calendar access mode.");
        Options = options with { RootDirectory = Path.GetFullPath(options.RootDirectory) };
        Options.RootDirectory.EnsureNoLinks();
        Directory.CreateDirectory(Options.RootDirectory);
        _clock = clock ?? TimeProvider.System;
        _file = Path.Combine(Options.RootDirectory, "calendar.json");
        _lease = new(Path.Combine(Options.RootDirectory, "host.lock"), FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
        try
        {
            _state = File.Exists(_file) ? JsonSerializer.Deserialize<CalendarState>(File.ReadAllText(_file))
                ?? throw new InvalidDataException("Invalid calendar state.") : new();
            if (_state.Entries.Count > 1000 || _state.Pending.Count > 100 || _state.Notices.Count > 1000)
                throw new InvalidDataException("Calendar limits exceeded.");
            // A crash may have left a queued notice. Retain one missed notice, never run actions.
            _state.Notices = _state.Notices.Select(n => n with { Missed = true, Message = MissedMessage(n.Title) }).ToList();
            Detect(true);
            Save();
        }
        catch { _lease.Dispose(); throw; }
    }

    public CalendarResult Execute(CalendarRequest request)
    {
        lock (_sync)
        {
            Check();
            return request.Operation switch
            {
                "create" or "update" or "delete" => Prepare(request),
                "read" => new("completed", "Calendar event.", Find(request.Id)),
                "search" => new("completed", "Calendar matches (up to 20).", _state.Entries
                    .Where(e => e.Title.Contains(request.Query, StringComparison.OrdinalIgnoreCase) || e.Notes.Contains(request.Query, StringComparison.OrdinalIgnoreCase) || e.Date == request.Query)
                    .OrderBy(e => e.Date).ThenBy(e => e.Time).Take(20).Select(Summary).ToArray()),
                "agenda" => Agenda(),
                "pending" => new("completed", "Pending calendar changes.", _state.Pending.ToArray()),
                _ => throw new ArgumentException("Unknown calendar operation.")
            };
        }
    }

    private CalendarResult Agenda()
    {
        var now = _clock.GetUtcNow();
        var events = _state.Entries.Where(e => e.Date == TimeZoneInfo.ConvertTime(now, Zone(e.TimeZone)).ToString("yyyy-MM-dd", CultureInfo.InvariantCulture))
            .OrderBy(e => e.Time).ToArray();
        var overdue = _state.Notices.Where(n => n.DueUtc <= now).ToArray();
        return new("completed", "Today's events and overdue reminders.", new { has_items = events.Length + overdue.Length > 0,
            event_count = events.Length, overdue_count = overdue.Length, events = events.Take(20).Select(Summary).ToArray(), overdue = overdue.Take(20).ToArray() });
    }

    private CalendarResult Prepare(CalendarRequest request)
    {
        // Persist exact absolute times and stable ID at preparation, never reinterpret on approval.
        if (request.Operation == "create" && request.Id.Length == 0) request = request with { Id = Guid.NewGuid().ToString("N") };
        CalendarEntry? prepared = Validate(request);
        if (prepared is not null) request = request with { TimeZone = prepared.TimeZone };
        if (Options.Mode == WorkspaceAccessMode.Yolo)
        {
            var result = Commit(request); Save(); return result;
        }
        if (_state.Pending.Count >= 100) throw new InvalidOperationException("Review existing calendar proposals first.");
        string id = Guid.NewGuid().ToString("N");
        _state.Pending.Add(new(id, request, _state.Entries.SingleOrDefault(e => e.Id == request.Id)?.Revision));
        Save();
        return new("needs_approval", $"Approve calendar {request.Operation}: {request.Title switch { "" => Find(request.Id).Title, _ => request.Title }}.", request, id);
    }

    public CalendarProposal Review(string id)
    {
        lock (_sync) { Check(); return _state.Pending.SingleOrDefault(p => p.Id == id) ?? throw new ArgumentException("Unknown calendar proposal."); }
    }
    public CalendarResult Approve(string id)
    {
        lock (_sync)
        {
            var proposal = Review(id);
            if (_state.Entries.SingleOrDefault(e => e.Id == proposal.Request.Id)?.Revision != proposal.ExpectedRevision)
                throw new InvalidOperationException("Calendar event changed. Reject this proposal and prepare another.");
            Validate(proposal.Request);
            var result = Commit(proposal.Request);
            _state.Pending.Remove(proposal); Save(); return result;
        }
    }
    public void Reject(string id) { lock (_sync) { var proposal = Review(id); _state.Pending.Remove(proposal); Save(); } }

    private CalendarEntry? Validate(CalendarRequest request)
    {
        if (request.Id.Length is < 1 or > 64 || request.Id.Any(c => !char.IsAsciiLetterOrDigit(c) && c is not ('_' or '-')))
            throw new ArgumentException("Event ID must contain 1-64 letters, digits, underscores or hyphens.");
        if (request.Operation == "create")
        {
            if (_state.Entries.Count >= 1000 || _state.Entries.Any(e => e.Id == request.Id)) throw new ArgumentException("Calendar ID exists or event limit reached.");
        }
        else
        {
            _ = Find(request.Id);
            if (_state.Notices.Any(n => n.EventId == request.Id)) throw new InvalidOperationException("Deliver this event's outstanding reminder before changing it.");
        }
        if (request.Operation == "delete") return null;
        if (request.Title.Length is < 1 or > 200 || string.IsNullOrWhiteSpace(request.Title) || request.Title.Any(char.IsControl) || request.Notes.Length > 2000 || request.Source.Length > 2000)
            throw new ArgumentException("Provide a title (1-200 visible characters), notes/source up to 2000 characters.");
        if (request.Source.Length > 0 && (!Uri.TryCreate(request.Source, UriKind.Absolute, out var uri) || uri.Scheme is not ("https" or "http")))
            throw new ArgumentException("Source must be an HTTP(S) URL.");
        if (!DateOnly.TryParseExact(request.Date, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var date)) throw new ArgumentException("Date must be yyyy-MM-dd.");
        if (_state.Entries.Any(e => e.Id != request.Id && e.Title.Equals(request.Title, StringComparison.OrdinalIgnoreCase) && e.Date == request.Date && e.Time == request.Time))
            throw new ArgumentException("This title/date/time is already in the calendar. Search and update the existing event instead.");
        var zone = Zone(request.TimeZone.Length == 0 ? TimeZoneInfo.Local.Id : request.TimeZone);
        DateTimeOffset? starts = request.Time.Length == 0 ? null : At(date, request.Time, zone);
        DateTimeOffset? reminder = request.Reminder switch
        {
            "none" => null,
            "" => throw new ArgumentException("Ask the user for a reminder time, or explicit none. Do not choose a default."),
            _ => ParseReminder(request.Reminder, zone)
        };
        if (reminder <= _clock.GetUtcNow()) throw new ArgumentException("Reminder must be in the future; ask for a new reminder time or none.");
        return new(request.Id, request.Title, request.Date, request.Time, zone.Id, starts, reminder, request.Notes, request.Source,
            request.Operation == "create" ? 1 : Find(request.Id).Revision + 1);
    }

    private static TimeZoneInfo Zone(string id) => TimeZoneInfo.FindSystemTimeZoneById(id);
    private static DateTimeOffset At(DateOnly date, string time, TimeZoneInfo zone)
    {
        if (!TimeOnly.TryParseExact(time, "HH:mm", CultureInfo.InvariantCulture, DateTimeStyles.None, out var parsed)) throw new ArgumentException("Time must be HH:mm.");
        var local = date.ToDateTime(parsed, DateTimeKind.Unspecified);
        if (zone.IsInvalidTime(local) || zone.IsAmbiguousTime(local)) throw new ArgumentException("Local time is invalid or ambiguous at a daylight-saving change. Choose an unambiguous local time.");
        return new DateTimeOffset(TimeZoneInfo.ConvertTimeToUtc(local, zone), TimeSpan.Zero);
    }
    private static DateTimeOffset ParseReminder(string value, TimeZoneInfo zone)
    {
        if (value.Length != 16 || value[10] != 'T' || !DateOnly.TryParseExact(value[..10], "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var date))
            throw new ArgumentException("Reminder must be yyyy-MM-ddTHH:mm in the event time zone, or none.");
        return At(date, value[11..], zone);
    }
    private CalendarResult Commit(CalendarRequest request)
    {
        var entry = Validate(request);
        string title = entry?.Title ?? Find(request.Id).Title;
        _state.Entries.RemoveAll(e => e.Id == request.Id);
        if (entry is not null) _state.Entries.Add(entry);
        return new("completed", $"Calendar {request.Operation} completed{(entry is null ? ": " + title : "")}.", entry);
    }
    public void Tick() { lock (_sync) { Check(); if (Detect(false)) Save(); } }
    private bool Detect(bool missed)
    {
        var due = _state.Entries.Where(e => !e.ReminderQueued && e.ReminderUtc <= _clock.GetUtcNow()).ToArray();
        foreach (var entry in due)
        {
            _state.Entries[_state.Entries.IndexOf(entry)] = entry with { ReminderQueued = true, Revision = entry.Revision + 1 };
            _state.Notices.Add(new(Guid.NewGuid().ToString("N"), entry.Id, entry.Title, entry.ReminderUtc!.Value, missed,
                missed ? MissedMessage(entry.Title) : $"Calendar reminder: {entry.Title}, {entry.Date}{(entry.Time.Length == 0 ? " (all day)" : " at " + entry.Time + " " + entry.TimeZone)}."));
        }
        return due.Length > 0;
    }
    private static string MissedMessage(string title) => $"Missed calendar reminder while Lilith was closed: {title}. No action was replayed.";
    public CalendarNotice? PeekNotice() { lock (_sync) { Check(); return _state.Notices.FirstOrDefault(); } }
    public void CompleteNotice(string id) { lock (_sync) { Check(); _state.Notices.RemoveAll(n => n.Id == id); Save(); } }
    private CalendarEntry Find(string id) => _state.Entries.SingleOrDefault(e => e.Id == id) ?? throw new ArgumentException("Unknown calendar event ID. Search the calendar first.");
    private static object Summary(CalendarEntry entry) => new { entry.Id, entry.Title, entry.Date, entry.Time, entry.TimeZone, entry.ReminderUtc };
    private void Save()
    {
        string temp = _file + "." + Guid.NewGuid().ToString("N") + ".tmp";
        try { File.WriteAllText(temp, JsonSerializer.Serialize(_state)); File.Move(temp, _file, true); }
        catch { _faulted = true; throw; }
    }
    private void Check() { ObjectDisposedException.ThrowIf(_disposed, this); if (_faulted) throw new IOException("Calendar storage failed. Fix storage and restart."); }
    public void Dispose() { lock (_sync) { if (_disposed) return; _disposed = true; _lease.Dispose(); } }
}

1
2
3
4
5
6
7
8
9

using System.Text.Json.Serialization;

namespace Lilith.Core.Chat;

public record ChatChunk(
    [property: JsonPropertyName("message")] ChatMessage? Message,
    [property: JsonPropertyName("done")] bool Done,
    [property: JsonPropertyName("prompt_eval_count")] int? PromptTokens,
    [property: JsonPropertyName("eval_count")] int? CompletionTokens);

1
2
3
4
5
6
7
8
9

using System.Text.Json.Serialization;

namespace Lilith.Core.Chat;

public class ChatHistory : List<ChatMessage>
{
    public void Add(string role, string content, int? tokens = null) =>
        Add(new ChatMessage(role, content, Tokens: tokens));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278

using System.Text.RegularExpressions;
using System.Xml.Linq;
using System.Text.Json;
using Lilith.Core.Tools;

namespace Lilith.Core.Chat;

public class ChatHistoryStore
{
    public string CurrentSessionId { get; private set; } = NewSessionId();
    public string RootDirectory { get; }

    public ChatHistoryStore() : this(null)
    {
    }

    /// <param name="rootDirectoryOverride">Optional folder for tests or custom deployments.</param>
    public ChatHistoryStore(string? rootDirectoryOverride)
    {
        if (!string.IsNullOrWhiteSpace(rootDirectoryOverride))
        {
            RootDirectory = rootDirectoryOverride;
            return;
        }

        string? envRoot = Environment.GetEnvironmentVariable("AGENT_CORE_CHAT_HISTORY_ROOT");
        if (!string.IsNullOrWhiteSpace(envRoot))
        {
            RootDirectory = envRoot;
            return;
        }

        string appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
        if (string.IsNullOrWhiteSpace(appData))
        {
            appData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
        }

        if (string.IsNullOrWhiteSpace(appData))
        {
            appData = AppContext.BaseDirectory;
        }

        RootDirectory = Path.Combine(appData, "AgentCore", DetectVersionLabel(), "ChatHistory");
    }

    public void StartNewSession() => CurrentSessionId = NewSessionId();

    public void UseSession(string id)
    {
        if (!string.IsNullOrWhiteSpace(id))
        {
            CurrentSessionId = SanitizeId(id);
        }
    }

    public string SaveSession(string model, IEnumerable<ChatMessage> history) =>
        SaveSession(CurrentSessionId, model, history);

    public string SaveSession(string? sessionId, string model, IEnumerable<ChatMessage> history)
    {
        Directory.CreateDirectory(RootDirectory);

        string id = string.IsNullOrWhiteSpace(sessionId) ? NewSessionId() : SanitizeId(sessionId);
        string path = SessionPath(id);
        DateTimeOffset now = DateTimeOffset.Now;
        DateTimeOffset createdAt = ReadCreatedAt(path) ?? now;
        var messages = history.Select(m => m.ToSavedMessage()).ToList();

        var doc = new XDocument(
            new XElement("chatSession",
                new XAttribute("id", id),
                new XAttribute("title", MakeTitle(messages)),
                new XAttribute("model", model),
                new XAttribute("createdAt", createdAt.ToString("O")),
                new XAttribute("updatedAt", now.ToString("O")),
                new XElement("messages",
                    messages.Select(m =>
                        new XElement("message",
                            new XAttribute("role", m.Role),
                            m.Tokens.HasValue ? new XAttribute("tokens", m.Tokens.Value) : null,
                            new XElement("content", m.Content),
                            m.ToolCalls is { Count: > 0 } ? new XElement("toolCalls", JsonSerializer.Serialize(m.ToolCalls)) : null,
                            m.ToolName is not null ? new XElement("toolName", m.ToolName) : null,
                            m.ToolCallId is not null ? new XElement("toolCallId", m.ToolCallId) : null,
                            m.Images is { Count: > 0 }
                                ? new XElement("images", m.Images.Select(i => new XElement("image", i)))
                                : null)))));

        AtomicFile.Write(path, doc.Save);
        CurrentSessionId = id;
        return id;
    }

    public IReadOnlyList<ChatSessionSummary> ListSessions()
    {
        if (!Directory.Exists(RootDirectory))
        {
            return [];
        }

        return Directory.EnumerateFiles(RootDirectory, "*.xml")
            .Select(ReadSummary)
            .Where(s => s is not null)
            .Select(s => s!)
            .OrderByDescending(s => s.UpdatedAt)
            .ToList();
    }

    public SavedChatSession? LoadSession(string id)
    {
        string path = SessionPath(SanitizeId(id));
        if (!File.Exists(path))
        {
            return null;
        }

        var session = ReadSession(path, SanitizeId(id));
        CurrentSessionId = session.Id;
        return session;
    }

    private static SavedChatSession ReadSession(string path, string id)
    {
        XDocument doc = XDocument.Load(path);
        XElement root = doc.Root ?? throw new InvalidDataException("Chat XML has no root.");
        if (root.Name != "chatSession" || root.Element("messages") is null ||
            ((string?)root.Attribute("id") is { } embedded && embedded != id))
            throw new InvalidDataException("Invalid chat session structure or identity.");
        var session = new SavedChatSession
        {
            Id = id,
            Title = (string?)root.Attribute("title") ?? "New chat",
            Model = (string?)root.Attribute("model") ?? string.Empty,
            CreatedAt = ParseDate((string?)root.Attribute("createdAt")) ?? DateTimeOffset.Now,
            UpdatedAt = ParseDate((string?)root.Attribute("updatedAt")) ?? DateTimeOffset.Now,
            Messages = root.Element("messages")?.Elements("message").Select(ReadMessage).ToList() ?? []
        };
        if (session.Messages.Count == 0) throw new InvalidDataException("Chat has no messages.");
        var pending = new Queue<ToolCall>();
        for (int i = 0; i < session.Messages.Count; i++)
        {
            var message = session.Messages[i];
            if (message.Role is not ("system" or "user" or "assistant" or "tool") || message.Tokens is < 0 ||
                (message.Role == "system" && (i != 0 || string.IsNullOrWhiteSpace(message.Content))))
                throw new InvalidDataException("Chat contains invalid messages.");
            if (message.Role == "tool")
            {
                if (!pending.TryDequeue(out var call) || message.ToolName != call.Function.Name || message.ToolCallId != call.Id ||
                    message.ToolCalls is { Count: > 0 })
                    throw new InvalidDataException("Chat contains an unmatched tool result.");
            }
            else
            {
                if (pending.Count != 0 || message.ToolName is not null || message.ToolCallId is not null)
                    throw new InvalidDataException("Chat contains an incomplete tool exchange.");
                if (message.ToolCalls is { Count: > 0 } calls)
                {
                    if (message.Role != "assistant") throw new InvalidDataException("Only assistants may call tools.");
                    foreach (var call in calls)
                    {
                        if (call?.Function is null || string.IsNullOrWhiteSpace(call.Function.Name) || call.Function.Arguments.ValueKind != JsonValueKind.Object)
                            throw new InvalidDataException("Invalid saved tool call.");
                        pending.Enqueue(call);
                    }
                }
            }
        }
        if (pending.Count != 0) throw new InvalidDataException("Chat ends with pending tool calls.");
        return session;
    }

    private string SessionPath(string id) => Path.Combine(RootDirectory, SanitizeId(id) + ".xml");

    private static SavedChatMessage ReadMessage(XElement element)
    {
        int? tokens = null;
        if (element.Attribute("tokens") is { } attribute)
        {
            if (!int.TryParse(attribute.Value, out int value)) throw new InvalidDataException("Invalid token count.");
            tokens = value;
        }
        var images = element.Element("images")?.Elements("image")
            .Select(i => i.Value)
            .Where(i => !string.IsNullOrWhiteSpace(i))
            .ToList();

        return new SavedChatMessage
        {
            Role = (string?)element.Attribute("role") ?? string.Empty,
            Content = element.Element("content")?.Value ?? string.Empty,
            Tokens = tokens,
            Images = images is { Count: > 0 } ? images : null,
            ToolCalls = element.Element("toolCalls") is { } calls ? JsonSerializer.Deserialize<List<ToolCall>>(calls.Value) : null,
            ToolName = element.Element("toolName")?.Value,
            ToolCallId = element.Element("toolCallId")?.Value
        };
    }

    private static ChatSessionSummary? ReadSummary(string path)
    {
        try
        {
            string id = Path.GetFileNameWithoutExtension(path);
            var session = ReadSession(path, id);
            return new ChatSessionSummary(
                id,
                session.Title, session.CreatedAt, session.UpdatedAt, session.Messages.Count, session.Model);
        }
        catch
        {
            return null;
        }
    }

    private static DateTimeOffset? ReadCreatedAt(string path)
    {
        if (!File.Exists(path))
        {
            return null;
        }

        try
        {
            XDocument doc = XDocument.Load(path);
            return ParseDate((string?)doc.Root?.Attribute("createdAt"));
        }
        catch
        {
            return null;
        }
    }

    private static DateTimeOffset? ParseDate(string? value) =>
        DateTimeOffset.TryParse(value, out var parsed) ? parsed : null;

    private static string MakeTitle(IReadOnlyList<SavedChatMessage> messages)
    {
        string? firstUser = messages
            .Where(m => m.Role.Equals("user", StringComparison.OrdinalIgnoreCase))
            .Select(m => m.Content.Trim())
            .FirstOrDefault(m => !string.IsNullOrWhiteSpace(m) &&
                !m.StartsWith("Please greet", StringComparison.OrdinalIgnoreCase) &&
                !m.Equals("hello", StringComparison.OrdinalIgnoreCase));

        if (string.IsNullOrWhiteSpace(firstUser))
        {
            firstUser = messages.FirstOrDefault(m => m.Role != "system" && !string.IsNullOrWhiteSpace(m.Content))?.Content.Trim();
        }

        if (string.IsNullOrWhiteSpace(firstUser))
        {
            return "New chat";
        }

        firstUser = RegexPatterns.Whitespace().Replace(firstUser, " ");
        return firstUser.Length <= 60 ? firstUser : firstUser[..57] + "...";
    }

    private static string DetectVersionLabel()
    {
        foreach (string source in new[] { AppContext.BaseDirectory, Environment.CurrentDirectory })
        {
            var match = RegexPatterns.VersionLabel().Match(source);
            if (match.Success)
            {
                return RegexPatterns.Whitespace().Replace(match.Value, " ");
            }
        }

        return "Default";
    }

    private static string NewSessionId() => DateTimeOffset.UtcNow.ToString("yyyyMMddHHmmssfff") + "-" + Guid.NewGuid().ToString("N");

    private static string SanitizeId(string id) =>
        string.Concat(id.Where(c => char.IsLetterOrDigit(c) || c is '-' or '_'));
}