Only the delta.

1
2
3
4

<Project>
  <!-- V12 project editing and bounded runtime acceptance. -->
  <PropertyGroup><VersionPrefix>12.0.0</VersionPrefix><VersionSuffix>alpha.1</VersionSuffix></PropertyGroup>
</Project>

1
2
3
4

<Project>
  <!-- V11 project generation. V10 is preserved as v10-before-v11. -->
  <PropertyGroup><VersionPrefix>11.0.0</VersionPrefix><VersionSuffix>alpha.1</VersionSuffix></PropertyGroup>
</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

using Lilith.Core.Commands;

namespace Lilith.Agent;

public partial class Lilith
{
    private readonly object _commandSync = new();
    private ChatCommandRegistry? _chatCommands;
    public ChatCommandRegistry ChatCommands { get { lock (_commandSync) return _chatCommands ??= CreateCommands(); } }

    private ChatCommandRegistry CreateCommands()
    {
        var commands = new ChatCommandRegistry();
        commands.Register("help", "List available chat commands.", context => { context.RequireNoArguments(); return commands.Help(); });
        commands.Register("new", "Start a new conversation.", context => { context.RequireNoArguments(); NewConversation(); return null; });
        commands.Register("history", "List saved chats or load one with /history <index>.", context => { HandleHistoryCommand("/history " + context.Arguments); return null; });
        commands.RegisterAsync("exit", "Save and exit the chat host.", context => { context.RequireNoArguments(); return Task.FromResult(new ChatCommandResult(true, ExitRequested: true)); });
        RegisterScenarioCommands(commands);
        RegisterWorkspaceCommands(commands);
        RegisterScheduleCommands(commands);
        RegisterWebResearchCommands(commands);
        RegisterPersonalityCommands(commands);
        global::Lilith.Core.Calendar.CalendarCommands.Register(commands, () => Client);
        global::Lilith.Core.Projects.ProjectCommands.Register(commands, () => Client);
        return commands;
    }

    partial void RegisterScenarioCommands(ChatCommandRegistry commands);
    partial void RegisterWorkspaceCommands(ChatCommandRegistry commands);
    partial void RegisterScheduleCommands(ChatCommandRegistry commands);
    partial void RegisterWebResearchCommands(ChatCommandRegistry commands);
    partial void RegisterPersonalityCommands(ChatCommandRegistry commands);
}

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

using Lilith.Core.Commands;

namespace Lilith.Agent;

public partial class Lilith
{
    private readonly object _commandSync = new();
    private ChatCommandRegistry? _chatCommands;
    public ChatCommandRegistry ChatCommands { get { lock (_commandSync) return _chatCommands ??= CreateCommands(); } }

    private ChatCommandRegistry CreateCommands()
    {
        var commands = new ChatCommandRegistry();
        commands.Register("help", "List available chat commands.", context => { context.RequireNoArguments(); return commands.Help(); });
        commands.Register("new", "Start a new conversation.", context => { context.RequireNoArguments(); NewConversation(); return null; });
        commands.Register("history", "List saved chats or load one with /history <index>.", context => { HandleHistoryCommand("/history " + context.Arguments); return null; });
        commands.RegisterAsync("exit", "Save and exit the chat host.", context => { context.RequireNoArguments(); return Task.FromResult(new ChatCommandResult(true, ExitRequested: true)); });
        RegisterScenarioCommands(commands);
        RegisterWorkspaceCommands(commands);
        RegisterScheduleCommands(commands);
        RegisterWebResearchCommands(commands);
        RegisterPersonalityCommands(commands);
        global::Lilith.Core.Calendar.CalendarCommands.Register(commands, () => Client);
        return commands;
    }

    partial void RegisterScenarioCommands(ChatCommandRegistry commands);
    partial void RegisterWorkspaceCommands(ChatCommandRegistry commands);
    partial void RegisterScheduleCommands(ChatCommandRegistry commands);
    partial void RegisterWebResearchCommands(ChatCommandRegistry commands);
    partial void RegisterPersonalityCommands(ChatCommandRegistry commands);
}

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

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

namespace Lilith.Core.Projects;

/// <summary>One visible browser for one explicitly approved qualification job.</summary>
internal sealed class ProjectBrowserSession : IDisposable
{
    private ChromeDriver? _driver;
    private ChromeDriverService? _service;
    internal Action<WebResearch.ResearchBrowserFrame>? Capture { get; set; }
    internal string Name { get; set; } = "project";
    internal ChromeDriver Get()
    {
        if (_driver is not null) return _driver;
        var options = WebResearch.BrowserResearchOptions.Load();
        string? directory = options.DriverDirectory;
        if (directory is null)
        {
            string cache = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".cache/selenium/chromedriver");
            directory = Directory.Exists(cache) ? Directory.EnumerateFiles(cache, "chromedriver.exe", SearchOption.AllDirectories).OrderByDescending(File.GetLastWriteTimeUtc).Select(Path.GetDirectoryName).FirstOrDefault() : null;
        }
        if (directory is null) throw new IOException("Existing ChromeDriver required; nothing is downloaded.");
        var chrome = new ChromeOptions(); if (options.ChromeBinary is not null) chrome.BinaryLocation = options.ChromeBinary;
        chrome.AddArguments("--no-first-run", "--disable-background-networking"); chrome.SetLoggingPreference(OpenQA.Selenium.LogType.Browser, LogLevel.All);
        _service = ChromeDriverService.CreateDefaultService(directory); _service.HideCommandPromptWindow = true;
        _driver = new ChromeDriver(_service, chrome, TimeSpan.FromSeconds(10));
        _driver.Manage().Timeouts().PageLoad = TimeSpan.FromSeconds(10); return _driver;
    }
    public void Dispose()
    {
        bool opened = _driver is not null;
        try { _driver?.Dispose(); }
        finally
        {
            _service?.Dispose(); _driver = null; _service = null;
            if (opened) Capture?.Invoke(new(DateTimeOffset.UtcNow, "project://" + Name, null, Closed: true, Purpose: "Project testing"));
        }
    }
}

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

using Lilith.Core.Commands;

namespace Lilith.Core.Projects;

public static class ProjectCommands
{
    public static void Register(ChatCommandRegistry commands, Func<ProviderClient> provider)
    {
        commands.Register("projects", "List private project drafts; no execution.", c => { c.RequireNoArguments(); return ProjectJson.Serialize(new ProjectDraftStore(provider().Workspace ?? throw new InvalidOperationException("Workspace unavailable.")).List()); });
        commands.Register("project-review", "Inspect source, frozen tests and evidence for one draft.", c => ProjectJson.Serialize(new ProjectDraftStore(provider().Workspace ?? throw new InvalidOperationException("Workspace unavailable.")).Load(c.Arguments)));
        commands.RegisterAsync("project-test", "Approve execution of one project and up to ten bounded test/repair rounds in visible Chrome or the console runner.", async c => new(true, await provider().ApproveProjectTestingAsync(c.Arguments, c.CancellationToken)));
        commands.RegisterAsync("project-publish", "Prepare one exact publication proposal for a successfully tested draft; does not approve workspace changes.", async c => new(true, await provider().PrepareProjectPublicationAsync(c.Arguments, c.CancellationToken)));
        string Pending(string state)
        {
            var store = new ProjectDraftStore(provider().Workspace ?? throw new InvalidOperationException("Workspace unavailable."));
            var ids = store.List().Select(d => System.Text.Json.JsonSerializer.SerializeToElement(d)).Where(d => d.GetProperty("State").GetString() == state).Select(d => d.GetProperty("Id").GetString()!).ToArray();
            return ids.Length == 1 ? ids[0] : throw new InvalidOperationException("Expected exactly one " + state + " draft. Use an explicit project ID.");
        }
        commands.RegisterAsync("project-test-pending", "Explicitly approve execution for the single pending draft; fails if there is more than one.", async c => { c.RequireNoArguments(); return new(true, await provider().ApproveProjectTestingAsync(Pending("awaiting_test_approval"), c.CancellationToken)); });
        commands.RegisterAsync("project-publish-pending", "Prepare publication for the single qualified draft; workspace approval remains separate.", async c => { c.RequireNoArguments(); return new(true, await provider().PrepareProjectPublicationAsync(Pending("ready_to_publish"), c.CancellationToken)); });
    }
}

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

namespace Lilith.Core.Projects;

public sealed record ProjectEdit(string Action, string Path, string? Content = null, string? Destination = null, string? Old = null);
public sealed record ProjectEditSet(ProjectEdit[] Changes);
[System.Text.Json.Serialization.JsonConverter(typeof(ProjectTestActionConverter))]
public sealed record ProjectTestAction(string Type, string Selector = "", string Value = "", int Width = 0, int Height = 0);
public sealed record ProjectTestCase(string Id, string Requirement, string Stdin = "", string[]? Contains = null,
    string[]? NotContains = null, int ExitCode = 0, ProjectTestAction[]? Actions = null);
public sealed record ProjectTestPlan(ProjectTestCase[] Cases);
public sealed record ProjectCaseResult(string Id, string Status, string Expected, string Actual);
public sealed record ProjectRuntimeReport(bool Passed, string SourceHash, string PlanHash, ProjectCaseResult[] Cases, string[] Errors, string Evidence);
public sealed record ProjectDraft(int SchemaVersion, string Id, string Name, string Kind, string Prd, string Request,
    ProjectArchitecture Architecture, ProjectSource[] Files, string? OriginalSignature, string[] OriginalManagedPaths,
    ProjectTestCase[] Tests, int Revision, string State, int Rounds, ProjectRuntimeReport? Runtime,
    string SourceReview = "Not reviewed", string? ProposalId = null);
public sealed record ProjectUpdateBundle(ProjectBundle Bundle, string[] OriginalManagedPaths);

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

using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using Lilith.Core.Workspace;
using Lilith.Core.Workspace.Extensions;

namespace Lilith.Core.Projects;

/// <summary>Persistent private copies. Only the explicit host testing command grants execution.</summary>
public sealed class ProjectDraftStore(WorkspaceSession workspace)
{
    internal WorkspaceSession Workspace => workspace;
    internal string Root => Path.Combine(workspace.Options.RootDirectory, ".lilith", "project-drafts");
    internal string Folder(string id)
    {
        if (!Regex.IsMatch(id, "^[a-f0-9]{32}$")) throw new ArgumentException("Invalid project draft ID.");
        string folder = Path.Combine(Root, id); folder.EnsureNoLinks(); return folder;
    }
    internal static string Hash(ProjectSource[] files) => Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(ProjectJson.Serialize(files.OrderBy(f => f.Path, StringComparer.Ordinal)))));
    internal static string PlanHash(ProjectTestCase[] tests) => Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(ProjectJson.Serialize(tests))));
    internal static void SourcePath(string path, string kind)
    {
        if (string.IsNullOrWhiteSpace(path) || path.Length > 100 || path.Contains('\\') || path.StartsWith('/') ||
            path is "lilith-project.json" or "PRD.txt" || path.Split('/').Any(p => !Regex.IsMatch(p, "^[A-Za-z][A-Za-z0-9_.-]*$") || p.StartsWith('.') || p.EndsWith('.') || Regex.IsMatch(p, @"^(CON|PRN|AUX|NUL|COM[0-9]|LPT[0-9])(?:\.|$)", RegexOptions.IgnoreCase)) ||
            (kind == "console" ? !path.EndsWith(".cs", StringComparison.Ordinal) : Path.GetExtension(path).ToLowerInvariant() is not (".html" or ".css" or ".js" or ".json" or ".txt")))
            throw new InvalidDataException("Invalid managed source path.");
    }
    internal static void ValidateFiles(ProjectSource[] files, string kind)
    {
        if (kind is not ("website" or "console") || files.Length is < 1 or > 12 || files.Select(f => f.Path).Distinct(StringComparer.OrdinalIgnoreCase).Count() != files.Length ||
            files.Any(f => f.Content is null || f.Content.Length > 16000) || files.Sum(f => f.Content.Length) > 40000) throw new InvalidDataException("Invalid candidate source bundle.");
        foreach (var file in files) SourcePath(file.Path, kind);
        if (kind == "website" && !new[] { "index.html", "styles.css", "app.js" }.All(p => files.Any(f => f.Path == p))) throw new InvalidDataException("Website requires index.html, styles.css and app.js.");
    }
    public ProjectDraft Load(string id)
    {
        string path = Path.Combine(Folder(id), "draft.json");
        path.EnsureNoLinks();
        if (new FileInfo(path).Length > 2000000) throw new InvalidDataException("Oversized draft.");
        var draft = ProjectJson.Parse<ProjectDraft>(File.ReadAllText(path));
        if (draft.SchemaVersion != 1 || draft.Id != id || !Regex.IsMatch(draft.Name, "^[A-Za-z][A-Za-z0-9_-]{0,47}$")) throw new InvalidDataException("Invalid draft identity.");
        ValidateFiles(draft.Files, draft.Kind); ValidateTests(draft.Tests, draft.Kind, allowEmpty: true);
        _ = workspace.Options.ResolvePath(draft.Name);
        if (draft.State == "awaiting_publication" && draft.ProposalId is { } proposal)
        {
            string receipt = workspace.Options.GetMetadataPath("receipts", proposal) + ".json";
            if (File.Exists(receipt)) { draft = draft with { State = "published" }; Save(draft); }
            else if (!File.Exists(workspace.Options.GetMetadataPath("pending", proposal) + ".json")) { draft = draft with { State = "publication_rejected" }; Save(draft); }
        }
        return draft;
    }
    internal void Save(ProjectDraft draft)
    {
        string folder = Folder(draft.Id); Directory.CreateDirectory(folder);
        string temporary = Path.Combine(folder, "draft-" + Guid.NewGuid().ToString("N") + ".tmp");
        File.WriteAllText(temporary, ProjectJson.Serialize(draft)); File.Move(temporary, Path.Combine(folder, "draft.json"), true);
    }
    public object[] List() => Directory.Exists(Root) ? Directory.EnumerateDirectories(Root).Select(Path.GetFileName).OfType<string>().Where(id => Regex.IsMatch(id, "^[a-f0-9]{32}$")).Select(id => { var d = Load(id); return (object)new { d.Id, d.Name, d.State, d.Revision, d.Rounds }; }).ToArray() : [];
    internal ProjectDraft Create(string name, string kind, string prd, string request, ProjectArchitecture architecture, ProjectSource[] files, string? originalSignature, string[] originalPaths)
    {
        if (!Regex.IsMatch(name, "^[A-Za-z][A-Za-z0-9_-]{0,47}$") || request.Length > 16000) throw new ArgumentException("Invalid project name/request.");
        ValidateFiles(files, kind);
        var draft = new ProjectDraft(1, Guid.NewGuid().ToString("N"), name, kind, prd, request, architecture, files, originalSignature, originalPaths, [], 0, "awaiting_test_plan", 0, null);
        Save(draft); return draft;
    }
    internal ProjectDraft Import(string name, string request)
    {
        if (!Regex.IsMatch(name, "^[A-Za-z][A-Za-z0-9_-]{0,47}$")) throw new ArgumentException("Use a project slug.");
        string target = workspace.Options.ResolvePath(name); target.EnsureNoLinks();
        string signature = target.ComputeSignature();
        var manifest = ProjectJson.Parse<ProjectManifest>(File.ReadAllText(Path.Combine(target, "lilith-project.json")));
        var files = new List<ProjectSource>();
        foreach (string path in manifest.Hashes.Keys.Where(p => p is not ("Application.csproj" or "PRD.txt")))
        {
            SourcePath(path, manifest.Kind);
            string full = workspace.Options.ResolvePath(name + "/" + path);
            files.Add(new(path, File.ReadAllText(full)));
        }
        foreach (string path in target.EnumerateEntries(10000, includeHidden: true).Where(File.Exists))
        {
            string relative = Path.GetRelativePath(target, path).Replace('\\', '/');
            if (relative.Split('/').Any(p => p.StartsWith('.') || p is "bin" or "obj") || relative is "Application.csproj" or "PRD.txt" or "lilith-project.json") continue;
            bool source = manifest.Kind == "console" ? relative.EndsWith(".cs", StringComparison.Ordinal) : Path.GetExtension(relative) is ".html" or ".css" or ".js" or ".json" or ".txt";
            if (source && files.All(f => !string.Equals(f.Path, relative, StringComparison.OrdinalIgnoreCase))) { SourcePath(relative, manifest.Kind); files.Add(new(relative, File.ReadAllText(path))); }
        }
        // Import actual current contents (including user edits), then protect that exact baseline.
        return Create(name, manifest.Kind, manifest.Prd, request, new(manifest.Contract, manifest.Architecture, manifest.Packages), files.ToArray(), signature, manifest.Hashes.Keys.Concat(files.Select(f => f.Path)).Append("lilith-project.json").Distinct(StringComparer.OrdinalIgnoreCase).ToArray());
    }
    internal ProjectDraft Apply(string id, string json)
    {
        var draft = Load(id);
        if (draft.State is "published" or "awaiting_publication") throw new InvalidOperationException("Start a new edit session after publication preparation.");
        var patch = ProjectJson.Parse<ProjectEditSet>(json);
        if (patch.Changes is null || patch.Changes.Length > 20) throw new InvalidDataException("Use at most 20 source edits.");
        var files = draft.Files.ToDictionary(f => f.Path, f => f.Content, StringComparer.Ordinal);
        foreach (var change in patch.Changes)
        {
            SourcePath(change.Path, draft.Kind);
            switch (change.Action)
            {
                case "write": if (!files.ContainsKey(change.Path) || change.Content is null) throw new InvalidDataException("Write requires an existing file and its complete new content."); files[change.Path] = change.Content; break;
                case "add": if (files.ContainsKey(change.Path) || change.Content is null) throw new InvalidDataException("Add requires a new file and complete content."); files.Add(change.Path, change.Content); break;
                case "replace":
                    if (!files.TryGetValue(change.Path, out var source) || string.IsNullOrEmpty(change.Old) || change.Content is null) throw new InvalidDataException("Replace requires current exact old text and new content.");
                    int at = source.IndexOf(change.Old, StringComparison.Ordinal);
                    if (at < 0 || source.IndexOf(change.Old, at + 1, StringComparison.Ordinal) >= 0) throw new InvalidDataException("Old text must match exactly once.");
                    files[change.Path] = source[..at] + change.Content + source[(at + change.Old.Length)..]; break;
                case "delete": if (!files.Remove(change.Path)) throw new InvalidDataException("Delete requires an existing managed file."); break;
                case "rename":
                    SourcePath(change.Destination ?? "", draft.Kind);
                    if (!files.Remove(change.Path, out var renamed) || !files.TryAdd(change.Destination!, renamed)) throw new InvalidDataException("Invalid rename."); break;
                default: throw new InvalidDataException("Unknown source edit action.");
            }
        }
        var candidate = files.Select(f => new ProjectSource(f.Key, f.Value)).ToArray(); ValidateFiles(candidate, draft.Kind);
        File.WriteAllText(Path.Combine(Folder(id), $"revision-{draft.Revision}.json"), ProjectJson.Serialize(draft));
        draft = draft with { Files = candidate, Revision = draft.Revision + 1, State = draft.Tests.Length == 0 ? "awaiting_test_plan" : "awaiting_test_approval", Runtime = null, SourceReview = "Not reviewed" };
        Save(draft); return draft;
    }
    internal object[] Backups(string name)
    {
        if (!Regex.IsMatch(name, "^[A-Za-z][A-Za-z0-9_-]{0,47}$")) throw new ArgumentException("Use a project slug.");
        string root = Path.Combine(workspace.Options.RootDirectory, ".lilith", "project-backups"); root.EnsureNoLinks();
        if (!Directory.Exists(root)) return [];
        return Directory.EnumerateDirectories(root).Select(Path.GetFileName).OfType<string>().Where(id => Regex.IsMatch(id, "^[a-f0-9]{32}$")).Where(id =>
        {
            string receipt = workspace.Options.GetMetadataPath("receipts", id) + ".json";
            if (!File.Exists(receipt)) return false;
            var result = ProjectJson.Parse<System.Text.Json.JsonElement>(File.ReadAllText(receipt));
            return result.TryGetProperty("Data", out var data) && data.TryGetProperty("path", out var path) && path.GetString() == name;
        }).Select(id => (object)new { id, name }).ToArray();
    }
    internal ProjectDraft Restore(string name, string backupId)
    {
        if (!Backups(name).Any(item => System.Text.Json.JsonSerializer.SerializeToElement(item).GetProperty("id").GetString() == backupId)) throw new IOException("No retained backup for this project.");
        string backup = workspace.Options.GetMetadataPath("project-backups", backupId);
        var manifest = ProjectJson.Parse<ProjectManifest>(File.ReadAllText(Path.Combine(backup, "lilith-project.json")));
        var current = Import(name, "Restore managed source from backup " + backupId + ". Preserve current unmanaged files.");
        var sources = manifest.Hashes.Keys.Where(p => p is not ("Application.csproj" or "PRD.txt")).Select(path =>
        {
            SourcePath(path, manifest.Kind); string full = Path.Combine(backup, path); full.EnsureNoLinks(); return new ProjectSource(path, File.ReadAllText(full));
        }).ToArray();
        ValidateFiles(sources, current.Kind);
        current = current with { Files = sources, Prd = manifest.Prd, Architecture = new(manifest.Contract, manifest.Architecture, manifest.Packages) }; Save(current); return current;
    }
    internal ProjectDraft AddTests(string id, string json)
    {
        var draft = Load(id); var plan = ProjectJson.Parse<ProjectTestPlan>(json);
        if (draft.State is "published" or "awaiting_publication") throw new InvalidOperationException("Start a new edit session after publication preparation.");
        ValidateTests(plan.Cases, draft.Kind, allowEmpty: draft.Tests.Length > 0);
        var tests = draft.Tests.ToDictionary(t => t.Id, StringComparer.Ordinal);
        foreach (var test in plan.Cases)
        {
            if (tests.TryGetValue(test.Id, out var old) && ProjectJson.Serialize(old) != ProjectJson.Serialize(test)) throw new InvalidDataException("Existing test cases cannot be changed or weakened; append new IDs.");
            tests[test.Id] = test;
        }
        ValidateTests(tests.Values.ToArray(), draft.Kind);
        draft = draft with { Tests = tests.Values.ToArray(), State = "awaiting_test_approval", Runtime = null }; Save(draft); return draft;
    }
    internal static void ValidateTests(ProjectTestCase[] tests, string kind, bool allowEmpty = false)
    {
        if (tests is null || tests.Any(t => t is null) || tests.Length > 40 || !allowEmpty && tests.Length == 0 || tests.Select(t => t.Id).Distinct(StringComparer.Ordinal).Count() != tests.Length || ProjectJson.Serialize(tests).Length > 64000) throw new InvalidDataException("Use 1-40 distinct tests within 64000 serialized characters.");
        foreach (var test in tests)
        {
            if (string.IsNullOrWhiteSpace(test.Id) || !Regex.IsMatch(test.Id, "^[A-Za-z][A-Za-z0-9_-]{0,63}$") || string.IsNullOrWhiteSpace(test.Requirement) || test.Requirement.Length > 1000 || test.Stdin is null || test.Stdin.Length > 8000) throw new InvalidDataException("Invalid test identity/requirement/input.");
            if (kind == "console") { if ((test.Contains?.Length ?? 0) + (test.NotContains?.Length ?? 0) == 0 || (test.Contains ?? []).Concat(test.NotContains ?? []).Any(s => string.IsNullOrEmpty(s) || s.Length > 2000)) throw new InvalidDataException("Console tests require output assertions."); }
            else
            {
                if (test.Actions is null || test.Actions.Length is < 1 or > 40 || !test.Actions.Any(a => a.Type is "assert_text" or "assert_visible" or "assert_js")) throw new InvalidDataException("Browser cases require bounded actions and assertions.");
                foreach (var action in test.Actions)
                {
                    if (action.Type is not ("click" or "key" or "type" or "wait" or "viewport" or "script" or "assert_text" or "assert_visible" or "assert_js") || action.Value.Length > 4000 || action.Selector.Length > 200 || action.Type == "viewport" && (action.Width is < 320 or > 1920 || action.Height is < 320 or > 1920)) throw new InvalidDataException("Invalid browser action.");
                    if ((action.Type is "click" or "type" or "assert_text" or "assert_visible") && string.IsNullOrWhiteSpace(action.Selector)) throw new InvalidDataException("This browser action requires a CSS selector.");
                    if ((action.Type is "assert_text" or "assert_js" or "script" or "key") && string.IsNullOrWhiteSpace(action.Value)) throw new InvalidDataException("This action requires a nonempty value/assertion; an empty expected string cannot pass a test.");
                    if (action.Type == "wait" && (!int.TryParse(action.Value, out int ms) || ms is < 0 or > 1000)) throw new InvalidDataException("Wait requires 0-1000 milliseconds.");
                }
            }
        }
    }
    internal object Inspect(string id)
    {
        string Clip(string text, int max) => text.Length <= max ? text : text[..max] + " [see full draft evidence]";
        var d = Load(id); return new { d.Id, d.Name, d.Kind, d.Prd, d.Request, d.State, d.Revision, d.Rounds,
            tests = d.Tests.Select(t => new { t.Id, requirement = Clip(t.Requirement, 200) }),
            runtime = d.Runtime is null ? null : new { d.Runtime.Passed, d.Runtime.Evidence, errors = d.Runtime.Errors.Take(3).Select(e => Clip(e, 500)), cases = d.Runtime.Cases.Select(c => new { c.Id, c.Status }) }, diagnostics = Clip(d.SourceReview, 2000),
            editAttempts = new[] { new { attempt = 1 }, new { attempt = 2 }, new { attempt = 3 } },
            sourceHash = Hash(d.Files), planHash = PlanHash(d.Tests), executionApproval = "Use /project-test " + id + ". This executes this project and its bounded repair revisions; workspace approval is separate." };
    }
}

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

namespace Lilith.Core.Projects;

internal static class ProjectEditingOperations
{
    internal static readonly string[] Names = ["project_edit_prepare_operation", "project_restore_prepare_operation", "project_backups_operation", "project_draft_read_operation", "project_draft_source_operation", "project_edit_require_operation", "project_tests_require_operation", "project_edit_apply_operation", "project_set_tests_operation", "project_run_tests_operation"];
    internal static async Task<string> ExecuteAsync(ProviderClient provider, string name, IReadOnlyDictionary<string, string> inputs, CancellationToken ct)
    {
        var store = new ProjectDraftStore(provider.Workspace ?? throw new InvalidOperationException("Project editing needs a workspace."));
        string Get(string key) => inputs.GetValueOrDefault(key, "");
        string id = Get("id");
        if (name == "project_draft_source_operation") return ProjectJson.Serialize(new { source = ProjectIntegrationCodec.Display(new(store.Load(id).Files)) });
        string Receipt(ProjectDraft draft) => ProjectJson.Serialize(new { planned = true, status = "awaiting_test_approval", draft.Id, draft.Name, tests = draft.Tests.Select(t => new { t.Id, t.Requirement }), message = "Private candidate and tests prepared. No generated application was run or published. Review with /project-review " + draft.Id + "; explicitly approve this project and up to ten test/repair rounds with /project-test " + draft.Id + ". Publication approval remains separate." });
        if (name == "project_tests_require_operation")
        {
            var draft = store.Load(id);
            if (draft.Tests.Length == 0 || draft.State != "awaiting_test_approval") throw new InvalidOperationException("No valid frozen test plan was prepared after three attempts. Nothing executed or published.");
            return Receipt(draft);
        }
        if (name == "project_edit_require_operation" && store.Load(id).Revision == 0) throw new InvalidOperationException("No valid source edit was prepared after three attempts. Private diagnostics are retained.");
        if (name == "project_backups_operation") return ProjectJson.Serialize(new { backups = store.Backups(Get("name")) });
        if (name == "project_restore_prepare_operation") return ProjectJson.Serialize(store.Inspect(store.Restore(Get("name"), Get("backup_id")).Id));
        if (name == "project_run_tests_operation")
        {
            if (provider.ProjectExecutionId != id) throw new InvalidOperationException("Explicit host execution approval required: /project-test <draft-id>. Models cannot approve execution.");
            return await ProjectQualification.RunAsync(provider, store, id, ct);
        }
        if (name == "project_edit_prepare_operation")
        {
            var draft = store.Import(Get("name"), Get("request")); return ProjectJson.Serialize(store.Inspect(draft.Id));
        }
        if (name is "project_edit_apply_operation" or "project_set_tests_operation")
        {
            // A separate host cannot change a draft while its qualification lease is held.
            using var lease = new FileStream(Path.Combine(store.Folder(id), "execution.lock"), FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
            if (name == "project_edit_apply_operation")
            {
                try { store.Apply(id, Get("changes")); return ProjectJson.Serialize(new { applied = true, id }); }
                catch (Exception ex) when (ex is InvalidDataException or System.Text.Json.JsonException)
                {
                    var draft = store.Load(id); store.Save(draft with { SourceReview = "Source edit was rejected: " + ex.Message });
                    return ProjectJson.Serialize(new { applied = false, id, diagnostics = ex.Message });
                }
            }
            else
            {
                try { return Receipt(store.AddTests(id, Get("plan"))); }
                catch (Exception ex) when (ex is InvalidDataException or System.Text.Json.JsonException)
                {
                    var draft = store.Load(id); store.Save(draft with { SourceReview = "Test plan was rejected: " + ex.Message });
                    return ProjectJson.Serialize(new { planned = false, id, diagnostics = ex.Message });
                }
            }
        }
        return ProjectJson.Serialize(store.Inspect(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
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

using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Text.Json;
using Lilith.Core.Workspace;
using Lilith.Core.Workspace.Extensions;

namespace Lilith.Core.Projects;

/// <summary>One scenario tree's private drafts; final publication uses an exact workspace proposal.</summary>
public sealed class ProjectGeneration(string evidenceRoot, WorkspaceSession workspace)
{
    private string? _id, _name, _kind, _prd;
    private ProjectArchitecture? _architecture;
    private ProjectTask[] _tasks = [];
    private readonly Dictionary<string, string> _components = new(StringComparer.Ordinal);
    private ProjectBundle? _bundle;
    private ProjectValidation? _validation;
    private string _diagnostics = "Not yet validated.";
    private string _reviewDiagnostics = "Independent review has not passed for the current source.";
    private bool _reviewPassed;
    private int _reviewNumber;
    internal ProjectBundle CurrentBundle => _bundle ?? throw new InvalidOperationException("Assemble the project before integration.");
    internal string CurrentDisplay => ProjectIntegrationCodec.Display(CurrentBundle);
    private string Folder => Path.Combine(evidenceRoot, "Projects", _id ?? throw new InvalidOperationException("Prepare a project first."));

    public string Prepare(string name, string kind, string prd, string architecture, bool validateOnly = false)
    {
        if (_id is not null) throw new InvalidOperationException("Only one generation per scenario tree.");
        if (!Regex.IsMatch(name, "^[A-Za-z][A-Za-z0-9_-]{0,47}$") || kind is not ("website" or "console") || prd.Length is < 30 or > 16000)
            throw new ArgumentException("Use a project slug, website/console kind and a detailed PRD of 30-16000 characters.");
        string destination = workspace.Options.ResolvePath(name);
        if (File.Exists(destination) || Directory.Exists(destination)) throw new IOException("Project target already exists. Choose a new project name; V11 does not edit projects.");
        ProjectArchitecture plan;
        if (kind == "website")
        {
            string contract = CleanCode(architecture);
            if (contract.Length < 80) throw new InvalidDataException("Website architecture needs a detailed shared interface contract.");
            plan = new(contract, [new("index.html", "", []), new("styles.css", "", []), new("app.js", "", [])], []);
        }
        else plan = ProjectJson.Architecture(architecture);
        if (string.IsNullOrWhiteSpace(plan.Contract) || plan.Contract.Length > 12000 || plan.Files is null || plan.Files.Length is < 1 or > 12)
            throw new InvalidDataException("Architecture needs a shared contract and 1-12 files.");
        if (kind == "console")
            plan = plan with { Files = plan.Files.Select(file =>
            {
                string skeleton = file.Skeleton ?? "";
                foreach (var method in file.Methods ?? [])
                {
                    if (string.IsNullOrWhiteSpace(method.Signature)) continue;
                    // Normalize only empty declarations adjacent to a slot, never replace implemented code.
                    skeleton = Regex.Replace(skeleton, @"/\*METHOD:[^*]+\*/\s*" + Regex.Escape(method.Signature) + @"\s*(?:;|\{\s*(?:/\*METHOD_BODY\*/)?\s*\})",
                        _ => "/*METHOD:" + method.Id + "*/", RegexOptions.CultureInvariant);
                }
                return file with { Skeleton = skeleton };
            }).ToArray() };
        var paths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        var tasks = new List<ProjectTask>();
        foreach (var file in plan.Files)
        {
            ValidateSourcePath(file.Path, kind);
            if (!paths.Add(file.Path) || file.Skeleton is null || file.Skeleton.Length > 16000 || file.Methods is null)
                throw new InvalidDataException("Invalid/duplicate architecture file.");
            if (kind == "website")
            {
                if (file.Methods.Length != 0) throw new InvalidDataException("Website tasks are whole files.");
                tasks.Add(new("file_" + tasks.Count, file.Path, "", plan.Contract));
            }
            else
            {
                foreach (var method in file.Methods)
                {
                    if (!Regex.IsMatch(method.Id, "^[A-Za-z][A-Za-z0-9_]{0,47}$") || tasks.Any(t => t.Id == method.Id) ||
                        string.IsNullOrWhiteSpace(method.Signature) || method.Signature.Length > 500 || method.Signature.IndexOfAny(['{', '}', ';']) >= 0 ||
                        !method.Signature.Contains('(') || !method.Signature.Contains(')') || string.IsNullOrWhiteSpace(method.Requirements) ||
                        file.Skeleton.Split("/*METHOD:" + method.Id + "*/", StringSplitOptions.None).Length != 2 || file.Skeleton.Contains(method.Signature, StringComparison.Ordinal))
                        throw new InvalidDataException("Each method requires a unique ID, signature, requirements and exactly one skeleton slot.");
                    tasks.Add(new(method.Id, file.Path, method.Signature, method.Requirements));
                }
                if (Regex.Matches(file.Skeleton, @"/\*METHOD:[^*]+\*/").Count != file.Methods.Length)
                    throw new InvalidDataException("Undeclared method slot.");
            }
        }
        if (tasks.Count is < 1 or > 20 || kind == "website" && !paths.SetEquals(["index.html", "styles.css", "app.js"]))
            throw new InvalidDataException("Use 1-20 tasks; websites require index.html, styles.css and app.js.");
        ValidatePackages(plan.Packages ?? [], kind);
        if (validateOnly) return ProjectJson.Serialize(new { valid = true, diagnostics = "Architecture contract validated." });
        _id = Guid.NewGuid().ToString("N"); _name = name; _kind = kind; _prd = prd;
        _architecture = plan with { Packages = plan.Packages ?? [] }; _tasks = tasks.ToArray();
        Folder.EnsureNoLinks(); Directory.CreateDirectory(Folder);
        File.WriteAllText(Path.Combine(Folder, "architecture.json"), ProjectJson.Serialize(_architecture));
        File.WriteAllText(Path.Combine(Folder, "prd.txt"), prd);
        return ProjectJson.Serialize(new { generation_id = _id,
            contract = plan.Contract + "\nFrozen file/class/method interfaces:\n" + ProjectJson.Serialize(plan.Files), tasks = _tasks,
            repairs = new[] { new { attempt = 1 }, new { attempt = 2 }, new { attempt = 3 } } });
    }

    public string Store(string generationId, string taskId, string content)
    {
        Require(generationId);
        _validation = null;
        _reviewPassed = false;
        var task = _tasks.SingleOrDefault(t => t.Id == taskId) ?? throw new ArgumentException("Unknown component task.");
        content = CleanCode(content);
        if (_kind == "website" && content.Split('\n', 2)[0].Trim() == task.Path)
            content = content[(content.IndexOf('\n') + 1)..].Trim();
        if (_components.ContainsKey(taskId) || content.Length is < 1 or > 16000) throw new InvalidDataException("Duplicate or oversized component.");
        if (_kind == "console" && (!content.StartsWith('{') || !content.EndsWith('}')))
            content = "{\n" + content + "\n}";
        _components.Add(task.Id, content);
        File.WriteAllText(Path.Combine(Folder, taskId + ".txt"), content);
        return ProjectJson.Serialize(new { stored = true, task_id = taskId });
    }

    public string Assemble(string generationId)
    {
        Require(generationId);
        _validation = null;
        _reviewPassed = false;
        if (_tasks.Any(t => !_components.ContainsKey(t.Id))) throw new InvalidOperationException("Every component must be reviewed and stored first.");
        var files = _architecture!.Files.Select(file =>
        {
            string content = _kind == "website" ? _components[_tasks.Single(t => t.Path == file.Path).Id] : file.Skeleton;
            if (_kind == "console") foreach (var method in file.Methods)
                content = content.Replace("/*METHOD:" + method.Id + "*/", method.Signature + "\n" + _components[method.Id], StringComparison.Ordinal);
            return new ProjectSource(file.Path, content);
        }).ToArray();
        _bundle = new(files);
        return ProjectJson.Serialize(new { display = CurrentDisplay });
    }

    public async Task<string> ValidateAsync(string generationId, string bundle, CancellationToken ct)
    {
        Require(generationId);
        _validation = null;
        _reviewPassed = false;
        if (_tasks.Any(t => !_components.ContainsKey(t.Id))) throw new InvalidOperationException("Review and store every component before validation.");
        ProjectBundle candidate;
        if (CleanCode(bundle).StartsWith('<')) candidate = ApplyChanges(CurrentBundle, ProjectIntegrationCodec.ParseXml(bundle));
        else
        {
            var integration = ProjectJson.Parse<JsonElement>(bundle);
            candidate = integration.TryGetProperty("changes", out _)
                ? ApplyChanges(CurrentBundle, ProjectJson.Parse<ProjectIntegration>(bundle))
                : ProjectJson.Parse<ProjectBundle>(bundle);
        }
        ValidateBundle(candidate, _kind!);
        if (!candidate.Files.Select(f => f.Path).ToHashSet(StringComparer.OrdinalIgnoreCase)
            .SetEquals(_architecture!.Files.Select(f => f.Path))) throw new InvalidDataException("Integration cannot add or remove planned files.");
        if (_kind == "console")
            foreach (var file in _architecture.Files)
                foreach (var method in file.Methods)
                    if (!candidate.Files.Single(f => f.Path == file.Path).Content.Contains(method.Signature, StringComparison.Ordinal))
                        throw new InvalidDataException("Integration changed or removed a contracted method signature: " + method.Id);
        _bundle = candidate;
        _validation = await ProjectValidator.ValidateAsync(_kind!, candidate, _architecture.Packages, Folder, ct);
        _diagnostics = string.Join("\n", _validation.Errors) + "\n" + _validation.BuildOutput;
        File.WriteAllText(Path.Combine(Folder, "validation.json"), ProjectJson.Serialize(_validation));
        File.WriteAllText(Path.Combine(Folder, "bundle.json"), ProjectJson.Serialize(candidate));
        return ProjectJson.Serialize(new { passed = _validation.Passed, report = _validation });
    }

    public async Task<WorkspaceResult> PublishAsync(string generationId, CancellationToken ct = default)
    {
        Require(generationId);
        if (_validation is not { Passed: true } || _bundle is null) throw new InvalidOperationException("Project validation has not passed. Nothing was published.");
        if (!_reviewPassed) throw new InvalidOperationException("Independent source review has not passed for the current revision. Nothing was published.");
        var files = _bundle.Files.ToList();
        if (_kind == "console") files.Add(new("Application.csproj", ProjectValidator.ProjectXml(_architecture!.Packages)));
        files.Add(new("PRD.txt", _prd!));
        var hashes = files.ToDictionary(f => f.Path, f => Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(f.Content))), StringComparer.Ordinal);
        var manifest = new ProjectManifest(1, _id!, _name!, _kind!, _prd!, _architecture!.Contract,
            _architecture.Packages, _architecture.Files, _tasks, _validation, hashes, DateTimeOffset.UtcNow, _reviewDiagnostics);
        files.Add(new("lilith-project.json", ProjectJson.Serialize(manifest)));
        string payload = ProjectJson.Serialize(new ProjectBundle(files.ToArray()));
        return await workspace.ExecuteAsync(new("project_create", _name!, payload), ct);
    }
    internal string Stage(string generationId)
    {
        Require(generationId);
        if (_validation is not { Passed: true } || !_reviewPassed || _bundle is null) throw new InvalidOperationException("Build and independent source review must pass before staging.");
        var draft = new ProjectDraftStore(workspace).Create(_name!, _kind!, _prd!, "Generate the project specified by the PRD.", _architecture!, _bundle.Files, null, []);
        return ProjectJson.Serialize(new { id = draft.Id, state = draft.State, message = "Private draft prepared. No application was executed or published." });
    }

    private void Require(string id)
    {
        if (_id is null || id != _id) throw new InvalidOperationException("Unknown generation in this scenario tree.");
    }
    internal void RecordDiagnostic(string message) => _diagnostics = message;
    internal string Inspect(string id)
    {
        Require(id);
        return ProjectJson.Serialize(new { display = CurrentDisplay, diagnostics = _diagnostics + "\nIndependent source review (not runtime evidence):\n" + _reviewDiagnostics });
    }
    internal string Review(string id, string report)
    {
        Require(id);
        _reviewPassed = false;
        bool reviewValid = false;
        try
        {
            if (report.Length > 12000) throw new InvalidDataException("Review exceeds 12000 characters.");
            var root = ProjectJson.Parse<JsonElement>(report);
            if (root.ValueKind != JsonValueKind.Object || !root.TryGetProperty("findings", out var findings) || findings.ValueKind != JsonValueKind.Array || findings.GetArrayLength() > 20)
                throw new InvalidDataException("Review must contain a findings array of at most 20 defects.");
            var ids = new HashSet<string>(StringComparer.Ordinal);
            foreach (var finding in findings.EnumerateArray())
            {
                string Text(string key) => finding.TryGetProperty(key, out var value) && value.ValueKind == JsonValueKind.String && !string.IsNullOrWhiteSpace(value.GetString())
                    ? value.GetString()! : throw new InvalidDataException("Review finding requires " + key + ".");
                string findingId = Text("id"), path = Text("path"), evidence = Text("evidence");
                _ = Text("problem"); _ = Text("fix");
                if (!ids.Add(findingId) || !CurrentBundle.Files.Any(f => f.Path == path && f.Content.Contains(evidence, StringComparison.Ordinal)))
                    throw new InvalidDataException("Review evidence must match current source and defect IDs must be unique.");
            }
            _reviewDiagnostics = root.GetRawText();
            reviewValid = true;
            _reviewPassed = findings.GetArrayLength() == 0;
        }
        catch (Exception ex) when (ex is InvalidDataException or JsonException or InvalidOperationException)
        { _reviewDiagnostics = "Invalid independent review: " + ex.Message + " Return the required findings JSON with exact current source evidence."; }
        File.WriteAllText(Path.Combine(Folder, $"review-{++_reviewNumber}.json"), ProjectJson.Serialize(new { sourceHash = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(CurrentDisplay))), reviewPassed = _reviewPassed, report, diagnostics = _reviewDiagnostics }));
        return ProjectJson.Serialize(new { passed = _validation is { Passed: true } && _reviewPassed, buildPassed = _validation?.Passed == true, reviewPassed = _reviewPassed, reviewValid,
            diagnostics = _diagnostics + "\n" + _reviewDiagnostics, runtimeTested = false });
    }
    private static ProjectBundle ApplyChanges(ProjectBundle bundle, ProjectIntegration integration)
    {
        if (integration.Changes is null || integration.Changes.Length > 20) throw new InvalidDataException("Use at most 20 exact integration changes.");
        var files = bundle.Files.ToDictionary(f => f.Path, f => f.Content, StringComparer.Ordinal);
        foreach (var change in integration.Changes)
        {
            if (change is null || !files.TryGetValue(change.Path, out var source) || string.IsNullOrEmpty(change.Old) || change.New is null || change.Old.Length > 8000 || change.New.Length > 8000)
                throw new InvalidDataException("Integration must change an existing file using bounded exact old/new text.");
            int at = source.IndexOf(change.Old, StringComparison.Ordinal);
            if (at < 0 || source.IndexOf(change.Old, at + 1, StringComparison.Ordinal) >= 0)
                throw new InvalidDataException("Integration old text must match exactly once: " + change.Path);
            files[change.Path] = source[..at] + change.New + source[(at + change.Old.Length)..];
        }
        return new(bundle.Files.Select(f => f with { Content = files[f.Path] }).ToArray());
    }
    internal static string CleanCode(string code)
    {
        code = code.Trim();
        if (!code.StartsWith("```", StringComparison.Ordinal)) return code;
        int first = code.IndexOf('\n');
        if (first < 0 || !code.EndsWith("```", StringComparison.Ordinal)) throw new InvalidDataException("Incomplete code fence.");
        return code[(first + 1)..^3].Trim();
    }
    internal static void ValidateSourcePath(string path, string kind)
    {
        if (string.IsNullOrWhiteSpace(path) || path.Length > 100 || path.Contains('\\') || path.StartsWith('/') ||
            path.Split('/').Any(p => !Regex.IsMatch(p, "^[A-Za-z][A-Za-z0-9_.-]*$") || p.EndsWith('.') ||
                Regex.IsMatch(p, @"^(CON|PRN|AUX|NUL|COM[0-9]|LPT[0-9])(?:\.|$)", RegexOptions.IgnoreCase)) ||
            (kind == "website" ? path is not ("index.html" or "styles.css" or "app.js") : !path.EndsWith(".cs", StringComparison.Ordinal)))
            throw new InvalidDataException("Invalid project source path.");
    }
    internal static void ValidateBundle(ProjectBundle bundle, string kind)
    {
        if (bundle.Files is null || bundle.Files.Length is < 1 or > 12 || bundle.Files.Select(f => f.Path).Distinct(StringComparer.OrdinalIgnoreCase).Count() != bundle.Files.Length ||
            bundle.Files.Any(f => f.Content is null || f.Content.Length > 16000) || bundle.Files.Sum(f => f.Content.Length) > 40000)
            throw new InvalidDataException("Invalid project bundle or size limit (40000 characters).");
        foreach (var file in bundle.Files) ValidateSourcePath(file.Path, kind);
    }
    private static void ValidatePackages(ProjectPackage[] packages, string kind)
    {
        if (packages.Length > 8 || kind == "website" && packages.Length != 0 || packages.Select(p => p.Id).Distinct(StringComparer.OrdinalIgnoreCase).Count() != packages.Length ||
            packages.Any(p => !Regex.IsMatch(p.Id, "^[A-Za-z][A-Za-z0-9_.-]{0,99}$") || !Regex.IsMatch(p.Version, @"^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$")))
            throw new InvalidDataException("Use up to eight exact-version NuGet packages. Website libraries use explicit HTTPS URLs in the PRD/contract.");
    }
}

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

using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Text.Json;
using Lilith.Core.Workspace;
using Lilith.Core.Workspace.Extensions;

namespace Lilith.Core.Projects;

/// <summary>One scenario tree's private drafts; final publication uses an exact workspace proposal.</summary>
public sealed class ProjectGeneration(string evidenceRoot, WorkspaceSession workspace)
{
    private string? _id, _name, _kind, _prd;
    private ProjectArchitecture? _architecture;
    private ProjectTask[] _tasks = [];
    private readonly Dictionary<string, string> _components = new(StringComparer.Ordinal);
    private ProjectBundle? _bundle;
    private ProjectValidation? _validation;
    private string _diagnostics = "Not yet validated.";
    private string _reviewDiagnostics = "Independent review has not passed for the current source.";
    private bool _reviewPassed;
    private int _reviewNumber;
    internal ProjectBundle CurrentBundle => _bundle ?? throw new InvalidOperationException("Assemble the project before integration.");
    internal string CurrentDisplay => ProjectIntegrationCodec.Display(CurrentBundle);
    private string Folder => Path.Combine(evidenceRoot, "Projects", _id ?? throw new InvalidOperationException("Prepare a project first."));

    public string Prepare(string name, string kind, string prd, string architecture, bool validateOnly = false)
    {
        if (_id is not null) throw new InvalidOperationException("Only one generation per scenario tree.");
        if (!Regex.IsMatch(name, "^[A-Za-z][A-Za-z0-9_-]{0,47}$") || kind is not ("website" or "console") || prd.Length is < 30 or > 16000)
            throw new ArgumentException("Use a project slug, website/console kind and a detailed PRD of 30-16000 characters.");
        string destination = workspace.Options.ResolvePath(name);
        if (File.Exists(destination) || Directory.Exists(destination)) throw new IOException("Project target already exists. Choose a new project name; V11 does not edit projects.");
        ProjectArchitecture plan;
        if (kind == "website")
        {
            string contract = CleanCode(architecture);
            if (contract.Length < 80) throw new InvalidDataException("Website architecture needs a detailed shared interface contract.");
            plan = new(contract, [new("index.html", "", []), new("styles.css", "", []), new("app.js", "", [])], []);
        }
        else plan = ProjectJson.Architecture(architecture);
        if (string.IsNullOrWhiteSpace(plan.Contract) || plan.Contract.Length > 12000 || plan.Files is null || plan.Files.Length is < 1 or > 12)
            throw new InvalidDataException("Architecture needs a shared contract and 1-12 files.");
        if (kind == "console")
            plan = plan with { Files = plan.Files.Select(file =>
            {
                string skeleton = file.Skeleton ?? "";
                foreach (var method in file.Methods ?? [])
                {
                    if (string.IsNullOrWhiteSpace(method.Signature)) continue;
                    // Normalize only empty declarations adjacent to a slot, never replace implemented code.
                    skeleton = Regex.Replace(skeleton, @"/\*METHOD:[^*]+\*/\s*" + Regex.Escape(method.Signature) + @"\s*(?:;|\{\s*(?:/\*METHOD_BODY\*/)?\s*\})",
                        _ => "/*METHOD:" + method.Id + "*/", RegexOptions.CultureInvariant);
                }
                return file with { Skeleton = skeleton };
            }).ToArray() };
        var paths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        var tasks = new List<ProjectTask>();
        foreach (var file in plan.Files)
        {
            ValidateSourcePath(file.Path, kind);
            if (!paths.Add(file.Path) || file.Skeleton is null || file.Skeleton.Length > 16000 || file.Methods is null)
                throw new InvalidDataException("Invalid/duplicate architecture file.");
            if (kind == "website")
            {
                if (file.Methods.Length != 0) throw new InvalidDataException("Website tasks are whole files.");
                tasks.Add(new("file_" + tasks.Count, file.Path, "", plan.Contract));
            }
            else
            {
                foreach (var method in file.Methods)
                {
                    if (!Regex.IsMatch(method.Id, "^[A-Za-z][A-Za-z0-9_]{0,47}$") || tasks.Any(t => t.Id == method.Id) ||
                        string.IsNullOrWhiteSpace(method.Signature) || method.Signature.Length > 500 || method.Signature.IndexOfAny(['{', '}', ';']) >= 0 ||
                        !method.Signature.Contains('(') || !method.Signature.Contains(')') || string.IsNullOrWhiteSpace(method.Requirements) ||
                        file.Skeleton.Split("/*METHOD:" + method.Id + "*/", StringSplitOptions.None).Length != 2 || file.Skeleton.Contains(method.Signature, StringComparison.Ordinal))
                        throw new InvalidDataException("Each method requires a unique ID, signature, requirements and exactly one skeleton slot.");
                    tasks.Add(new(method.Id, file.Path, method.Signature, method.Requirements));
                }
                if (Regex.Matches(file.Skeleton, @"/\*METHOD:[^*]+\*/").Count != file.Methods.Length)
                    throw new InvalidDataException("Undeclared method slot.");
            }
        }
        if (tasks.Count is < 1 or > 20 || kind == "website" && !paths.SetEquals(["index.html", "styles.css", "app.js"]))
            throw new InvalidDataException("Use 1-20 tasks; websites require index.html, styles.css and app.js.");
        ValidatePackages(plan.Packages ?? [], kind);
        if (validateOnly) return ProjectJson.Serialize(new { valid = true, diagnostics = "Architecture contract validated." });
        _id = Guid.NewGuid().ToString("N"); _name = name; _kind = kind; _prd = prd;
        _architecture = plan with { Packages = plan.Packages ?? [] }; _tasks = tasks.ToArray();
        Folder.EnsureNoLinks(); Directory.CreateDirectory(Folder);
        File.WriteAllText(Path.Combine(Folder, "architecture.json"), ProjectJson.Serialize(_architecture));
        File.WriteAllText(Path.Combine(Folder, "prd.txt"), prd);
        return ProjectJson.Serialize(new { generation_id = _id,
            contract = plan.Contract + "\nFrozen file/class/method interfaces:\n" + ProjectJson.Serialize(plan.Files), tasks = _tasks,
            repairs = new[] { new { attempt = 1 }, new { attempt = 2 }, new { attempt = 3 } } });
    }

    public string Store(string generationId, string taskId, string content)
    {
        Require(generationId);
        _validation = null;
        _reviewPassed = false;
        var task = _tasks.SingleOrDefault(t => t.Id == taskId) ?? throw new ArgumentException("Unknown component task.");
        content = CleanCode(content);
        if (_kind == "website" && content.Split('\n', 2)[0].Trim() == task.Path)
            content = content[(content.IndexOf('\n') + 1)..].Trim();
        if (_components.ContainsKey(taskId) || content.Length is < 1 or > 16000) throw new InvalidDataException("Duplicate or oversized component.");
        if (_kind == "console" && (!content.StartsWith('{') || !content.EndsWith('}')))
            content = "{\n" + content + "\n}";
        _components.Add(task.Id, content);
        File.WriteAllText(Path.Combine(Folder, taskId + ".txt"), content);
        return ProjectJson.Serialize(new { stored = true, task_id = taskId });
    }

    public string Assemble(string generationId)
    {
        Require(generationId);
        _validation = null;
        _reviewPassed = false;
        if (_tasks.Any(t => !_components.ContainsKey(t.Id))) throw new InvalidOperationException("Every component must be reviewed and stored first.");
        var files = _architecture!.Files.Select(file =>
        {
            string content = _kind == "website" ? _components[_tasks.Single(t => t.Path == file.Path).Id] : file.Skeleton;
            if (_kind == "console") foreach (var method in file.Methods)
                content = content.Replace("/*METHOD:" + method.Id + "*/", method.Signature + "\n" + _components[method.Id], StringComparison.Ordinal);
            return new ProjectSource(file.Path, content);
        }).ToArray();
        _bundle = new(files);
        return ProjectJson.Serialize(new { display = CurrentDisplay });
    }

    public async Task<string> ValidateAsync(string generationId, string bundle, CancellationToken ct)
    {
        Require(generationId);
        _validation = null;
        _reviewPassed = false;
        if (_tasks.Any(t => !_components.ContainsKey(t.Id))) throw new InvalidOperationException("Review and store every component before validation.");
        ProjectBundle candidate;
        if (CleanCode(bundle).StartsWith('<')) candidate = ApplyChanges(CurrentBundle, ProjectIntegrationCodec.ParseXml(bundle));
        else
        {
            var integration = ProjectJson.Parse<JsonElement>(bundle);
            candidate = integration.TryGetProperty("changes", out _)
                ? ApplyChanges(CurrentBundle, ProjectJson.Parse<ProjectIntegration>(bundle))
                : ProjectJson.Parse<ProjectBundle>(bundle);
        }
        ValidateBundle(candidate, _kind!);
        if (!candidate.Files.Select(f => f.Path).ToHashSet(StringComparer.OrdinalIgnoreCase)
            .SetEquals(_architecture!.Files.Select(f => f.Path))) throw new InvalidDataException("Integration cannot add or remove planned files.");
        if (_kind == "console")
            foreach (var file in _architecture.Files)
                foreach (var method in file.Methods)
                    if (!candidate.Files.Single(f => f.Path == file.Path).Content.Contains(method.Signature, StringComparison.Ordinal))
                        throw new InvalidDataException("Integration changed or removed a contracted method signature: " + method.Id);
        _bundle = candidate;
        _validation = await ProjectValidator.ValidateAsync(_kind!, candidate, _architecture.Packages, Folder, ct);
        _diagnostics = string.Join("\n", _validation.Errors) + "\n" + _validation.BuildOutput;
        File.WriteAllText(Path.Combine(Folder, "validation.json"), ProjectJson.Serialize(_validation));
        File.WriteAllText(Path.Combine(Folder, "bundle.json"), ProjectJson.Serialize(candidate));
        return ProjectJson.Serialize(new { passed = _validation.Passed, report = _validation });
    }

    public async Task<WorkspaceResult> PublishAsync(string generationId, CancellationToken ct = default)
    {
        Require(generationId);
        if (_validation is not { Passed: true } || _bundle is null) throw new InvalidOperationException("Project validation has not passed. Nothing was published.");
        if (!_reviewPassed) throw new InvalidOperationException("Independent source review has not passed for the current revision. Nothing was published.");
        var files = _bundle.Files.ToList();
        if (_kind == "console") files.Add(new("Application.csproj", ProjectValidator.ProjectXml(_architecture!.Packages)));
        files.Add(new("PRD.txt", _prd!));
        var hashes = files.ToDictionary(f => f.Path, f => Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(f.Content))), StringComparer.Ordinal);
        var manifest = new ProjectManifest(1, _id!, _name!, _kind!, _prd!, _architecture!.Contract,
            _architecture.Packages, _architecture.Files, _tasks, _validation, hashes, DateTimeOffset.UtcNow, _reviewDiagnostics);
        files.Add(new("lilith-project.json", ProjectJson.Serialize(manifest)));
        string payload = ProjectJson.Serialize(new ProjectBundle(files.ToArray()));
        return await workspace.ExecuteAsync(new("project_create", _name!, payload), ct);
    }

    private void Require(string id)
    {
        if (_id is null || id != _id) throw new InvalidOperationException("Unknown generation in this scenario tree.");
    }
    internal void RecordDiagnostic(string message) => _diagnostics = message;
    internal string Inspect(string id)
    {
        Require(id);
        return ProjectJson.Serialize(new { display = CurrentDisplay, diagnostics = _diagnostics + "\nIndependent source review (not runtime evidence):\n" + _reviewDiagnostics });
    }
    internal string Review(string id, string report)
    {
        Require(id);
        _reviewPassed = false;
        bool reviewValid = false;
        try
        {
            if (report.Length > 12000) throw new InvalidDataException("Review exceeds 12000 characters.");
            var root = ProjectJson.Parse<JsonElement>(report);
            if (root.ValueKind != JsonValueKind.Object || !root.TryGetProperty("findings", out var findings) || findings.ValueKind != JsonValueKind.Array || findings.GetArrayLength() > 20)
                throw new InvalidDataException("Review must contain a findings array of at most 20 defects.");
            var ids = new HashSet<string>(StringComparer.Ordinal);
            foreach (var finding in findings.EnumerateArray())
            {
                string Text(string key) => finding.TryGetProperty(key, out var value) && value.ValueKind == JsonValueKind.String && !string.IsNullOrWhiteSpace(value.GetString())
                    ? value.GetString()! : throw new InvalidDataException("Review finding requires " + key + ".");
                string findingId = Text("id"), path = Text("path"), evidence = Text("evidence");
                _ = Text("problem"); _ = Text("fix");
                if (!ids.Add(findingId) || !CurrentBundle.Files.Any(f => f.Path == path && f.Content.Contains(evidence, StringComparison.Ordinal)))
                    throw new InvalidDataException("Review evidence must match current source and defect IDs must be unique.");
            }
            _reviewDiagnostics = root.GetRawText();
            reviewValid = true;
            _reviewPassed = findings.GetArrayLength() == 0;
        }
        catch (Exception ex) when (ex is InvalidDataException or JsonException or InvalidOperationException)
        { _reviewDiagnostics = "Invalid independent review: " + ex.Message + " Return the required findings JSON with exact current source evidence."; }
        File.WriteAllText(Path.Combine(Folder, $"review-{++_reviewNumber}.json"), ProjectJson.Serialize(new { sourceHash = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(CurrentDisplay))), reviewPassed = _reviewPassed, report, diagnostics = _reviewDiagnostics }));
        return ProjectJson.Serialize(new { passed = _validation is { Passed: true } && _reviewPassed, buildPassed = _validation?.Passed == true, reviewPassed = _reviewPassed, reviewValid,
            diagnostics = _diagnostics + "\n" + _reviewDiagnostics, runtimeTested = false });
    }
    private static ProjectBundle ApplyChanges(ProjectBundle bundle, ProjectIntegration integration)
    {
        if (integration.Changes is null || integration.Changes.Length > 20) throw new InvalidDataException("Use at most 20 exact integration changes.");
        var files = bundle.Files.ToDictionary(f => f.Path, f => f.Content, StringComparer.Ordinal);
        foreach (var change in integration.Changes)
        {
            if (change is null || !files.TryGetValue(change.Path, out var source) || string.IsNullOrEmpty(change.Old) || change.New is null || change.Old.Length > 8000 || change.New.Length > 8000)
                throw new InvalidDataException("Integration must change an existing file using bounded exact old/new text.");
            int at = source.IndexOf(change.Old, StringComparison.Ordinal);
            if (at < 0 || source.IndexOf(change.Old, at + 1, StringComparison.Ordinal) >= 0)
                throw new InvalidDataException("Integration old text must match exactly once: " + change.Path);
            files[change.Path] = source[..at] + change.New + source[(at + change.Old.Length)..];
        }
        return new(bundle.Files.Select(f => f with { Content = files[f.Path] }).ToArray());
    }
    internal static string CleanCode(string code)
    {
        code = code.Trim();
        if (!code.StartsWith("```", StringComparison.Ordinal)) return code;
        int first = code.IndexOf('\n');
        if (first < 0 || !code.EndsWith("```", StringComparison.Ordinal)) throw new InvalidDataException("Incomplete code fence.");
        return code[(first + 1)..^3].Trim();
    }
    internal static void ValidateSourcePath(string path, string kind)
    {
        if (string.IsNullOrWhiteSpace(path) || path.Length > 100 || path.Contains('\\') || path.StartsWith('/') ||
            path.Split('/').Any(p => !Regex.IsMatch(p, "^[A-Za-z][A-Za-z0-9_.-]*$") || p.EndsWith('.') ||
                Regex.IsMatch(p, @"^(CON|PRN|AUX|NUL|COM[0-9]|LPT[0-9])(?:\.|$)", RegexOptions.IgnoreCase)) ||
            (kind == "website" ? path is not ("index.html" or "styles.css" or "app.js") : !path.EndsWith(".cs", StringComparison.Ordinal)))
            throw new InvalidDataException("Invalid project source path.");
    }
    internal static void ValidateBundle(ProjectBundle bundle, string kind)
    {
        if (bundle.Files is null || bundle.Files.Length is < 1 or > 12 || bundle.Files.Select(f => f.Path).Distinct(StringComparer.OrdinalIgnoreCase).Count() != bundle.Files.Length ||
            bundle.Files.Any(f => f.Content is null || f.Content.Length > 16000) || bundle.Files.Sum(f => f.Content.Length) > 40000)
            throw new InvalidDataException("Invalid project bundle or size limit (40000 characters).");
        foreach (var file in bundle.Files) ValidateSourcePath(file.Path, kind);
    }
    private static void ValidatePackages(ProjectPackage[] packages, string kind)
    {
        if (packages.Length > 8 || kind == "website" && packages.Length != 0 || packages.Select(p => p.Id).Distinct(StringComparer.OrdinalIgnoreCase).Count() != packages.Length ||
            packages.Any(p => !Regex.IsMatch(p.Id, "^[A-Za-z][A-Za-z0-9_.-]{0,99}$") || !Regex.IsMatch(p.Version, @"^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$")))
            throw new InvalidDataException("Use up to eight exact-version NuGet packages. Website libraries use explicit HTTPS URLs in the PRD/contract.");
    }
}

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

namespace Lilith.Core.Projects;

public sealed record ProjectMethod(string Id, string Signature, string Requirements);
public sealed record ProjectFile(string Path, string Skeleton, ProjectMethod[] Methods);
public sealed record ProjectPackage(string Id, string Version);
public sealed record ProjectArchitecture(string Contract, ProjectFile[] Files, ProjectPackage[] Packages);
public sealed record ProjectTask(string Id, string Path, string Signature, string Requirements);
public sealed record ProjectSource(string Path, string Content);
public sealed record ProjectBundle(ProjectSource[] Files);
public sealed record ProjectChange(string Path, string Old, string New);
public sealed record ProjectIntegration(ProjectChange[] Changes);
public sealed record ProjectValidation(bool Passed, string Kind, string[] Checks, string[] Errors, string BuildOutput, string? BuildDirectory = null);
public sealed record ProjectManifest(int SchemaVersion, string GenerationId, string Name, string Kind, string Prd,
    string Contract, ProjectPackage[] Packages, ProjectFile[] Architecture, ProjectTask[] Tasks,
    ProjectValidation Validation, Dictionary<string, string> Hashes, DateTimeOffset CreatedAt, string? IndependentSourceReview = null,
    ProjectRuntimeReport? Runtime = null, ProjectTestCase[]? AcceptanceTests = null);

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

namespace Lilith.Core.Projects;

public sealed record ProjectMethod(string Id, string Signature, string Requirements);
public sealed record ProjectFile(string Path, string Skeleton, ProjectMethod[] Methods);
public sealed record ProjectPackage(string Id, string Version);
public sealed record ProjectArchitecture(string Contract, ProjectFile[] Files, ProjectPackage[] Packages);
public sealed record ProjectTask(string Id, string Path, string Signature, string Requirements);
public sealed record ProjectSource(string Path, string Content);
public sealed record ProjectBundle(ProjectSource[] Files);
public sealed record ProjectChange(string Path, string Old, string New);
public sealed record ProjectIntegration(ProjectChange[] Changes);
public sealed record ProjectValidation(bool Passed, string Kind, string[] Checks, string[] Errors, string BuildOutput);
public sealed record ProjectManifest(int SchemaVersion, string GenerationId, string Name, string Kind, string Prd,
    string Contract, ProjectPackage[] Packages, ProjectFile[] Architecture, ProjectTask[] Tasks,
    ProjectValidation Validation, Dictionary<string, string> Hashes, DateTimeOffset CreatedAt, string? IndependentSourceReview = null);

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

namespace Lilith.Core.Projects;

internal static class ProjectOperations
{
    internal static readonly string[] Names = ["project_check_architecture_operation", "project_prepare_operation", "project_store_operation", "project_assemble_operation", "project_inspect_operation", "project_validate_operation", "project_review_operation", "project_stage_operation"];
    internal static async Task<string> ExecuteAsync(ProjectGeneration projects, string name, IReadOnlyDictionary<string, string> inputs, CancellationToken ct)
    {
        string Get(string key) => inputs.GetValueOrDefault(key, "");
        ct.ThrowIfCancellationRequested();
        if (name == "project_check_architecture_operation")
        {
            try { return projects.Prepare(Get("name"), Get("kind"), Get("prd"), Get("architecture"), validateOnly: true); }
            catch (Exception ex) when (ex is ArgumentException or InvalidDataException or System.Text.Json.JsonException)
            { return ProjectJson.Serialize(new { valid = false, diagnostics = ex.Message }); }
        }
        if (name == "project_validate_operation")
        {
            try { return await projects.ValidateAsync(Get("generation_id"), Get("bundle"), ct); }
            catch (Exception ex) when (ex is InvalidDataException or System.Text.Json.JsonException or System.Xml.XmlException)
            {
                projects.RecordDiagnostic(ex.Message);
                return ProjectJson.Serialize(new { passed = false, report = new { errors = new[] { ex.Message }, checks = Array.Empty<string>(), buildOutput = "" } });
            }
        }
        return name switch
        {
            "project_prepare_operation" => projects.Prepare(Get("name"), Get("kind"), Get("prd"), Get("architecture")),
            "project_store_operation" => projects.Store(Get("generation_id"), Get("task_id"), Get("content")),
            "project_assemble_operation" => projects.Assemble(Get("generation_id")),
            "project_inspect_operation" => projects.Inspect(Get("generation_id")),
            "project_review_operation" => projects.Review(Get("generation_id"), Get("report")),
            "project_stage_operation" => projects.Stage(Get("generation_id")),
            _ => throw new ArgumentException("Unknown project operation.")
        };
    }
}

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

namespace Lilith.Core.Projects;

internal static class ProjectOperations
{
    internal static readonly string[] Names = ["project_check_architecture_operation", "project_prepare_operation", "project_store_operation", "project_assemble_operation", "project_inspect_operation", "project_validate_operation", "project_review_operation", "project_publish_operation"];
    internal static async Task<string> ExecuteAsync(ProjectGeneration projects, string name, IReadOnlyDictionary<string, string> inputs, CancellationToken ct)
    {
        string Get(string key) => inputs.GetValueOrDefault(key, "");
        ct.ThrowIfCancellationRequested();
        if (name == "project_check_architecture_operation")
        {
            try { return projects.Prepare(Get("name"), Get("kind"), Get("prd"), Get("architecture"), validateOnly: true); }
            catch (Exception ex) when (ex is ArgumentException or InvalidDataException or System.Text.Json.JsonException)
            { return ProjectJson.Serialize(new { valid = false, diagnostics = ex.Message }); }
        }
        if (name == "project_validate_operation")
        {
            try { return await projects.ValidateAsync(Get("generation_id"), Get("bundle"), ct); }
            catch (Exception ex) when (ex is InvalidDataException or System.Text.Json.JsonException or System.Xml.XmlException)
            {
                projects.RecordDiagnostic(ex.Message);
                return ProjectJson.Serialize(new { passed = false, report = new { errors = new[] { ex.Message }, checks = Array.Empty<string>(), buildOutput = "" } });
            }
        }
        return name switch
        {
            "project_prepare_operation" => projects.Prepare(Get("name"), Get("kind"), Get("prd"), Get("architecture")),
            "project_store_operation" => projects.Store(Get("generation_id"), Get("task_id"), Get("content")),
            "project_assemble_operation" => projects.Assemble(Get("generation_id")),
            "project_inspect_operation" => projects.Inspect(Get("generation_id")),
            "project_review_operation" => projects.Review(Get("generation_id"), Get("report")),
            "project_publish_operation" => ProjectJson.Serialize(await projects.PublishAsync(Get("generation_id"), ct)),
            _ => throw new ArgumentException("Unknown project operation.")
        };
    }
}

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

using Lilith.Core.Scenarios;
using Lilith.Core.Workspace;
using Lilith.Core.Workspace.Extensions;

namespace Lilith.Core.Projects;

internal static class ProjectQualification
{
    private static string Clip(string value, int max) => value.Length <= max ? value : value[..max] + "\n[truncated; full evidence retained]";
    internal static async Task<string> Scenario(ProviderClient provider, string name, IReadOnlyDictionary<string, string> inputs, CancellationToken ct)
    {
        var files = new ScenarioFileService();
        var result = await new ScenarioExecutor(provider, files).RunXmlAsync(files.Bind(name, inputs), ct);
        return result.Output;
    }
    internal static Dictionary<string, string> Inputs(ProjectDraft draft, string diagnostics = "No runtime evidence yet.") => new()
    {
        ["kind"] = draft.Kind, ["prd"] = Clip(draft.Prd, 7000), ["request"] = Clip(draft.Request, 3000),
        ["source"] = ProjectIntegrationCodec.Display(new(draft.Files)), ["diagnostics"] = Clip(diagnostics, 5000)
    };
    internal static async Task<string> RunAsync(ProviderClient provider, ProjectDraftStore store, string id, CancellationToken ct,
        Func<ProjectDraft, string, CancellationToken, Task<ProjectRuntimeReport>>? runner = null)
    {
        var draft = store.Load(id); ProjectDraftStore.ValidateTests(draft.Tests, draft.Kind);
        if (draft.State is "published" or "awaiting_publication") throw new InvalidOperationException("Start a fresh qualification/edit session.");
        string folder = store.Folder(id);
        using var lease = new FileStream(Path.Combine(folder, "execution.lock"), FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
        using var browserSession = new ProjectBrowserSession();
        draft = draft with { State = "testing", Rounds = 0, Runtime = null }; store.Save(draft);
        try
        {
            for (int round = 1; round <= 10; round++)
            {
                ct.ThrowIfCancellationRequested(); draft = store.Load(id) with { State = "testing", Rounds = round }; store.Save(draft);
                string evidence = Path.Combine(folder, "runs", DateTime.UtcNow.ToString("yyyyMMdd-HHmmss") + "-" + Guid.NewGuid().ToString("N")[..8], "round-" + round);
                evidence.EnsureNoLinks();
                ProjectRuntimeReport report;
                try { report = runner is null ? await ProjectRuntimeRunner.RunAsync(draft, evidence, ct, provider.HasProjectFrameCapture ? provider.CaptureProjectFrame : null, browserSession) : await runner(draft, evidence, ct); }
                catch (Exception ex) when (!ct.IsCancellationRequested)
                {
                    report = new(false, ProjectDraftStore.Hash(draft.Files), ProjectDraftStore.PlanHash(draft.Tests), [], ["Runtime infrastructure/test error: " + ex.Message], evidence);
                    Directory.CreateDirectory(evidence); File.WriteAllText(Path.Combine(evidence, "runtime.json"), ProjectJson.Serialize(report));
                }
                draft = draft with { Runtime = report with { Cases = report.Cases.Select(c => c with { Expected = Clip(c.Expected, 1000), Actual = Clip(c.Actual, 2000) }).ToArray(), Errors = report.Errors.Select(e => Clip(e, 2000)).ToArray() } }; store.Save(draft);
                string diagnostics = ProjectJson.Serialize(new { report.Passed, report.Errors, cases = report.Cases.Where(c => c.Status != "passed").Select(c => c with { Actual = Clip(c.Actual, 1000) }).Take(10), report.Evidence }) + "\nPrevious repair/source-review issue: " + Clip(draft.SourceReview, 2000);
                provider.ReportScenario(new(id, "project_test", "Round", $"Project {draft.Name}: round {round}/10, runtime {(report.Passed ? "passed" : "failed")}. Evidence: {evidence}", round, 10));
                if (report.Passed)
                {
                    try
                    {
                    string review = await Scenario(provider, "project_review_project", new Dictionary<string, string> {
                        ["kind"] = draft.Kind, ["prd"] = Clip(draft.Prd + "\nRequested change: " + draft.Request, 10000), ["bundle"] = ProjectIntegrationCodec.Display(new(draft.Files)), ["diagnostics"] = Clip(diagnostics, 5000) }, ct);
                    var root = ProjectJson.Parse<System.Text.Json.JsonElement>(review);
                    bool clean = root.TryGetProperty("findings", out var findings) && findings.ValueKind == System.Text.Json.JsonValueKind.Array && findings.GetArrayLength() == 0;
                    draft = draft with { SourceReview = review }; store.Save(draft);
                    if (clean)
                    {
                        // Independent coverage agent may only append tests; every existing assertion is retained.
                        var coverageInputs = Inputs(draft, "All current tests passed. Append missing behavioral/boundary tests only; do not change existing cases. Current immutable tests: " + Clip(ProjectJson.Serialize(draft.Tests), 5000));
                        string additions = await Scenario(provider, "project_test_expand", coverageInputs, ct);
                        var extra = ProjectJson.Parse<ProjectTestPlan>(additions);
                        ProjectDraftStore.ValidateTests(extra.Cases, draft.Kind, allowEmpty: true);
                        if (extra.Cases.Length > 0)
                        {
                            additions = await Scenario(provider, "project_review_tests", new Dictionary<string,string> { ["kind"] = draft.Kind, ["prd"] = Clip(draft.Prd, 7000), ["request"] = Clip(draft.Request, 3000), ["source"] = ProjectIntegrationCodec.Display(new(draft.Files)), ["plan"] = additions }, ct);
                            extra = ProjectJson.Parse<ProjectTestPlan>(additions); ProjectDraftStore.ValidateTests(extra.Cases, draft.Kind, allowEmpty: true);
                        }
                        if (extra.Cases.Length == 0)
                        {
                            draft = draft with { State = "ready_to_publish" }; store.Save(draft);
                            return ProjectJson.Serialize(new { status = draft.State, draft.Id, rounds = round, checks = report.Cases.Length, message = "Declared runtime tests and independent source review passed on this revision; coverage is limited to these checks.", command = "/project-publish " + id, evidence });
                        }
                        if (extra.Cases.Any(t => draft.Tests.Any(old => old.Id == t.Id))) throw new InvalidDataException("Coverage must append NEW test IDs, not repeat existing cases.");
                        draft = store.AddTests(id, additions);
                        if (round == 10) break;
                        continue;
                    }
                    diagnostics += "\nIndependent source findings (not runtime evidence): " + Clip(review, 5000);
                    }
                    catch (Exception ex) when (!ct.IsCancellationRequested)
                    {
                        diagnostics += "\nIndependent review/test-plan error (do not change source merely to fix report formatting): " + ex.Message;
                        draft = store.Load(id) with { SourceReview = diagnostics }; store.Save(draft);
                    }
                }
                if (round == 10) break;
                draft = draft with { State = "repairing" }; store.Save(draft);
                try
                {
                    string changes = await Scenario(provider, "project_repair", Inputs(draft, diagnostics), ct);
                    var proposed = ProjectJson.Parse<System.Text.Json.JsonElement>(changes);
                    if (proposed.TryGetProperty("test_issues", out var issues) && issues.ValueKind == System.Text.Json.JsonValueKind.Array && issues.GetArrayLength() > 0)
                    {
                        if (issues.GetArrayLength() > 10) throw new InvalidDataException("Report at most ten suspected test issues.");
                        foreach (var issue in issues.EnumerateArray())
                        {
                            string? testId = issue.GetProperty("id").GetString(), reason = issue.GetProperty("reason").GetString();
                            if (!draft.Tests.Any(t => t.Id == testId) || string.IsNullOrWhiteSpace(reason) || reason.Length > 1000) throw new InvalidDataException("Test issue requires an existing case ID and bounded reason.");
                        }
                        draft = store.Load(id) with { SourceReview = "AI-reported suspected test-plan issue (not independently verified). Frozen tests were not changed: " + issues.GetRawText() }; store.Save(draft);
                        break;
                    }
                    draft = store.Apply(id, changes);
                }
                catch (Exception ex) when (!ct.IsCancellationRequested)
                {
                    // Do not silently skip failed repairs or restart the round budget.
                    draft = store.Load(id) with { SourceReview = "Repair/test-plan error: " + ex.Message };
                    store.Save(draft);
                }
            }
            draft = store.Load(id) with { State = "failed" }; store.Save(draft);
            return ProjectJson.Serialize(new { status = "failed", draft.Id, rounds = draft.Rounds, message = (draft.Rounds == 10 ? "Ten-round qualification limit reached." : "Qualification stopped with unresolved errors or a suspected frozen-test issue.") + " Nothing was published. Full errors and action traces are retained in the evidence folder.",
                remaining = draft.Runtime is null ? null : new { draft.Runtime.SourceHash, draft.Runtime.PlanHash, errors = draft.Runtime.Errors.Take(10).Select(e => Clip(e, 500)), cases = draft.Runtime.Cases.Where(c => c.Status != "passed").Select(c => c with { Actual = Clip(c.Actual, 500), Expected = Clip(c.Expected, 200) }), draft.Runtime.Evidence },
                unqualifiedTests = draft.Tests.Where(t => draft.Runtime is null || !draft.Runtime.Cases.Any(c => c.Id == t.Id && c.Status == "passed")).Select(t => t.Id), sourceReview = Clip(draft.SourceReview, 2000), evidence = folder });
        }
        catch (OperationCanceledException) { store.Save(store.Load(id) with { State = "cancelled", Runtime = null }); throw; }
        catch (Exception ex) { store.Save(store.Load(id) with { State = "failed", SourceReview = ex.Message }); throw; }
    }
    internal static async Task<WorkspaceResult> PublishAsync(ProjectDraftStore store, string id, CancellationToken ct)
    {
        using var lease = new FileStream(Path.Combine(store.Folder(id), "execution.lock"), FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
        var draft = store.Load(id);
        if (draft.State != "ready_to_publish" || draft.Runtime is not { Passed: true } runtime || runtime.SourceHash != ProjectDraftStore.Hash(draft.Files) || runtime.PlanHash != ProjectDraftStore.PlanHash(draft.Tests)) throw new InvalidOperationException("Current source and complete test plan must pass before publication.");
        string target = store.Workspace.Options.ResolvePath(draft.Name);
        if (target.ComputeSignature() != (draft.OriginalSignature ?? "missing")) throw new IOException("Original project changed. Create a fresh edit session; nothing was overwritten.");
        var files = draft.Files.ToList();
        if (draft.Kind == "console") files.Add(new("Application.csproj", ProjectValidator.ProjectXml(draft.Architecture.Packages)));
        files.Add(new("PRD.txt", draft.Prd));
        var hashes = files.ToDictionary(f => f.Path, f => Convert.ToHexString(System.Security.Cryptography.SHA256.HashData(System.Text.Encoding.UTF8.GetBytes(f.Content))), StringComparer.Ordinal);
        var manifest = new ProjectManifest(2, draft.Id, draft.Name, draft.Kind, draft.Prd, draft.Architecture.Contract, draft.Architecture.Packages, draft.Architecture.Files, [], new(true, draft.Kind, ["Current-revision build, declared runtime tests and independent source review"], [], "See retained runtime evidence."), hashes, DateTimeOffset.UtcNow, draft.SourceReview, runtime, draft.Tests);
        files.Add(new("lilith-project.json", ProjectJson.Serialize(manifest)));
        var bundle = new ProjectBundle(files.ToArray());
        string payload = draft.OriginalSignature is null ? ProjectJson.Serialize(bundle) : ProjectJson.Serialize(new ProjectUpdateBundle(bundle, draft.OriginalManagedPaths));
        var result = await store.Workspace.ExecuteAsync(new(draft.OriginalSignature is null ? "project_create" : "project_update", draft.Name, payload), ct);
        store.Save(draft with { State = result.Status == "needs_approval" ? "awaiting_publication" : "published", ProposalId = result.ProposalId }); return result;
    }
}