Program.cs

using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Text.Json;
using CodeMesh.Control.AgentAccess;
using CodeMesh.Control.Configuration;
using CodeMesh.Control.Diagnostics;
using CodeMesh.Domain.Contracts;
using CodeMesh.Domain.Graph;
using CodeMesh.Domain.Health;
using CodeMesh.Domain.Utilities;
using CodeMesh.Ingestion;
using CodeMesh.Ingestion.Embedding;
using CodeMesh.Ingestion.Summary;
using CodeMesh.Ingestion.Summary.Qualification;
using CodeMesh.Parser.CSharp;
using CodeMesh.Parser.Deployment;
using CodeMesh.Parser.Markdown;
using CodeMesh.Parser.Python;
using CodeMesh.Parser.Rust;
using CodeMesh.Storage;
using CodeMesh.Storage.Memory;
using CodeMesh.Storage.Mongo;
using CodeMesh.Storage.Neo4j;
using CodeMesh.Storage.Qdrant;
using MongoDB.Bson;
using MongoDB.Driver;

var tests = new (string Name, Func<Task> Run)[]
{
    ("sha256 helper is deterministic", TestHash),
    ("repository path policy ignores generated directories", TestRepositoryPathPolicyIgnoresGeneratedDirectories),
    ("repository path policy rejects linked paths", TestRepositoryPathPolicyRejectsLinkedPaths),
    ("repository path policy excludes known secrets and applies filters", TestRepositoryPathPolicyExcludesKnownSecretsAndAppliesFilters),
    ("repository path policy rejects unsafe patterns", TestRepositoryPathPolicyRejectsUnsafePatterns),
    ("environment file loader fills missing variables", TestEnvironmentFileLoaderFillsMissingVariables),
    ("ingest path resolver accepts repository and caller relative files", TestIngestPathResolverAcceptsRelativeFiles),
    ("ingest path resolver rejects missing explicit files", TestIngestPathResolverRejectsMissingFiles),
    ("refresh workflow resolves repository root", TestRefreshWorkflowResolvesRepositoryRoot),
    ("refresh workflow normalizes ingest arguments", TestRefreshWorkflowNormalizesIngestArguments),
    ("watch workflow normalizes refresh arguments", TestWatchWorkflowNormalizesRefreshArguments),
    ("watch workflow detects file changes", TestWatchWorkflowDetectsFileChanges),
    ("self workflow resolves repository root", TestSelfWorkflowResolvesRepositoryRoot),
    ("self workflow normalizes ingest arguments", TestSelfWorkflowNormalizesIngestArguments),
    ("self workflow rejects invalid roots", TestSelfWorkflowRejectsInvalidRoots),
    ("agent access contracts map REST JSON", TestAgentAccessContractsMapRestJson),
    ("agent access client calls REST endpoints", TestAgentAccessClientCallsRestEndpoints),
    ("ingestion writes parser output", TestIngestionWritesParserOutput),
    ("multi-language ingestion publishes one deterministic snapshot", TestMultiLanguageIngestionPublishesOneDeterministicSnapshot),
    ("ingestion redacts sensitive content before stores and embeddings", TestIngestionRedactsSensitiveContentBeforeStoresAndEmbeddings),
    ("dry-run ingestion skips stores", TestDryRunSkipsStores),
    ("repository refresh removes stale records", TestRepositoryRefreshRemovesStaleRecords),
    ("incremental ingestion skips unchanged records", TestIncrementalIngestionSkipsUnchangedRecords),
    ("incremental ingestion skips unchanged summaries", TestIncrementalIngestionSkipsUnchangedSummaries),
    ("summary budgets scale with node complexity", TestSummaryBudgetsScaleWithNodeComplexity),
    ("summary generator persists budget metadata", TestSummaryGeneratorPersistsBudgetMetadata),
    ("summary generator regenerates when configuration changes", TestSummaryGeneratorRegeneratesWhenConfigurationChanges),
    ("summary qualification runner redacts inputs and enforces evidence gates", TestSummaryQualificationRunnerAndCompiler),
    ("forced embedding ingestion rebuilds unchanged embeddings", TestForcedEmbeddingIngestionRebuildsUnchangedEmbeddings),
    ("embedding verifier reports missing and stale vectors", TestEmbeddingVerifierReportsMissingAndStaleVectors),
    ("repository cleanup removes indexed data", TestRepositoryCleanupRemovesIndexedData),
    ("repository aliases are generated and resolved", TestRepositoryAliasesAreGeneratedAndResolved),
    ("ingestion stamps git repository metadata", TestIngestionStampsGitRepositoryMetadata),
    ("ingestion writes repository registry records", TestIngestionWritesRepositoryRegistryRecords),
    ("snapshot slots retain clean heads and bound dirty history", TestSnapshotSlotsRetainCleanHeadsAndBoundDirtyHistory),
    ("checkout identity survives moves and rejects live copies", TestCheckoutIdentitySurvivesMovesAndRejectsLiveCopies),
    ("linked worktrees share projects but not checkouts", TestLinkedWorktreesShareProjectsButNotCheckouts),
    ("explicit pins protect snapshots until released", TestExplicitPinsProtectSnapshotsUntilReleased),
    ("failed snapshot generations preserve active slots", TestFailedSnapshotGenerationPreservesActiveSlots),
    ("status uses configured ollama endpoint", TestStatusUsesConfiguredOllamaEndpoint),
    ("status retries transient ollama failures", TestStatusRetriesTransientOllamaFailures),
    ("status degrades when configured model is missing", TestStatusDegradesWhenConfiguredModelIsMissing),
    ("ollama embedding provider maps responses", TestOllamaEmbeddingProviderMapsResponses),
    ("lm studio embedding provider maps responses", TestLmStudioEmbeddingProviderMapsResponses),
    ("lm studio summary provider accepts numeric confidence", TestLmStudioSummaryProviderAcceptsNumericConfidence),
    ("ollama summary provider uses request completion budget", TestOllamaSummaryProviderUsesRequestCompletionBudget),
    ("openai summary provider uses responses structured output", TestOpenAiSummaryProviderUsesResponsesStructuredOutput),
    ("openai summary provider records provider-default effort", TestOpenAiSummaryProviderRecordsProviderDefaultEffort),
    ("mongodb content store round-trips content", TestMongoContentStoreRoundTripsContent),
    ("mongodb summary store migrates generation identity", TestMongoSummaryStoreMigratesGenerationIdentity),
    ("mongodb registry store round-trips repositories and runs", TestMongoRegistryStoreRoundTripsRepositoriesAndRuns),
    ("neo4j graph store round-trips graph", TestNeo4jGraphStoreRoundTripsGraph),
    ("qdrant vector store round-trips embeddings", TestQdrantVectorStoreRoundTripsEmbeddings),
    ("csharp parser emits Roslyn symbols", TestCSharpParserEmitsRoslynSymbols),
    ("csharp parser emits test files and cases", TestCSharpParserEmitsTestFilesAndCases),
    ("csharp parser emits invocation and member access relationships", TestCSharpParserEmitsInvocationAndMemberAccessRelationships),
    ("csharp parser emits cross-project invocation relationships", TestCSharpParserEmitsCrossProjectInvocationRelationships),
    ("csharp parser separates partial declarations from symbols", TestCSharpParserSeparatesPartialDeclarations),
    ("csharp parser honors project compile items", TestCSharpParserHonorsProjectCompileItems),
    ("csharp parser preserves isolated design-time editor configuration", TestCSharpParserDesignTimeEditorConfiguration),
    ("csharp parser applies repository path filters", TestCSharpParserAppliesRepositoryPathFilters),
    ("deployment parser emits Dockerfile and Compose nodes", TestDeploymentParserEmitsDockerfileAndComposeNodes),
    ("deployment parser parses repository runtime artifacts", TestDeploymentParserParsesRepositoryRuntimeArtifacts),
    ("markdown parser emits documents sections and containment", TestMarkdownParserEmitsDocumentsSectionsAndContainment),
    ("markdown parser parses repository docs", TestMarkdownParserParsesRepositoryDocs),
    ("python parser emits classes functions and containment", TestPythonParserEmitsClassesFunctionsAndContainment),
    ("python parser emits imports calls and test cases", TestPythonParserEmitsImportsCallsAndTestCases),
    ("python parser parses Agent Access project", TestPythonParserParsesAgentAccessProject),
    ("rust parser emits declarations relationships tests and PyO3 exports", TestRustParserEmitsDeclarationsRelationshipsTestsAndPyO3Exports),
    ("composite parser links Python calls to Rust PyO3 exports", TestCompositeParserLinksPythonCallsToRustPyO3Exports),
    ("csharp parser parses YoutubeDownloader sample", TestYoutubeDownloaderSampleParser)
};

var failures = 0;
var skipped = 0;

foreach (var test in tests)
{
    try
    {
        await test.Run().ConfigureAwait(false);
        Console.WriteLine($"[pass] {test.Name}");
    }
    catch (SkipTestException exception)
    {
        skipped++;
        Console.WriteLine($"[skip] {test.Name}: {exception.Message}");
    }
    catch (Exception exception)
    {
        failures++;
        Console.Error.WriteLine($"[fail] {test.Name}: {exception.Message}");
    }
}

if (failures > 0)
{
    Console.Error.WriteLine($"{failures} test(s) failed.");
    return 1;
}

Console.WriteLine($"{tests.Length - skipped} test(s) passed, {skipped} skipped.");
return 0;

static Task TestHash()
{
    Equal(
        "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
        CodeMeshHash.Sha256Hex("abc"),
        "SHA-256 output changed.");

    return Task.CompletedTask;
}

static Task TestRepositoryPathPolicyIgnoresGeneratedDirectories()
{
    Equal(true, RepositoryPathPolicy.IsIgnoredRelativePath("agent-access/.venv/lib/package.md"), "Repository path policy did not ignore .venv content.");
    Equal(true, RepositoryPathPolicy.IsIgnoredRelativePath(".tmp/fixture/package.md"), "Repository path policy did not ignore temporary content.");
    Equal(true, RepositoryPathPolicy.IsIgnoredRelativePath(".codemesh-smoke/run/Fixture.cs"), "Repository path policy did not ignore smoke output.");
    Equal(true, RepositoryPathPolicy.IsIgnoredRelativePath("package.egg-info/PKG-INFO"), "Repository path policy did not ignore Python package metadata.");
    Equal(false, RepositoryPathPolicy.IsIgnoredRelativePath("docs/evaluation/testing.md"), "Repository path policy ignored repository documentation.");

    return Task.CompletedTask;
}

static Task TestRepositoryPathPolicyRejectsLinkedPaths()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-path-link-root-{Guid.NewGuid():N}");
    var outside = Path.Combine(Path.GetTempPath(), $"codemesh-path-link-outside-{Guid.NewGuid():N}");
    Directory.CreateDirectory(root);
    Directory.CreateDirectory(outside);

    try
    {
        var outsideFile = Path.Combine(outside, "External.cs");
        var normalFile = Path.Combine(root, "Normal.cs");
        File.WriteAllText(outsideFile, "public sealed class External;");
        File.WriteAllText(normalFile, "public sealed class Normal;");
        var linkedDirectory = Path.Combine(root, "linked-directory");
        var linkedFile = Path.Combine(root, "Linked.cs");
        try
        {
            Directory.CreateSymbolicLink(linkedDirectory, outside);
            File.CreateSymbolicLink(linkedFile, outsideFile);
        }
        catch (Exception exception) when (
            exception is PlatformNotSupportedException or
            UnauthorizedAccessException or
            IOException)
        {
            return Task.CompletedTask;
        }

        Equal(true, RepositoryPathPolicy.IsIgnoredPath(root, linkedDirectory), "Repository path policy did not reject a linked directory.");
        Equal(true, RepositoryPathPolicy.IsIgnoredPath(root, Path.Combine(linkedDirectory, "External.cs")), "Repository path policy did not reject a file below a linked directory.");
        Equal(true, RepositoryPathPolicy.IsIgnoredPath(root, linkedFile), "Repository path policy did not reject a linked file.");
        Equal(false, RepositoryPathPolicy.IsIgnoredPath(root, normalFile), "Repository path policy rejected a normal repository file.");
        var enumerated = RepositoryPathPolicy.EnumerateFiles(root, "*.cs")
            .Select(Path.GetFileName)
            .Order(StringComparer.Ordinal)
            .ToArray();
        Equal(1, enumerated.Length, "Repository traversal included a linked file or traversed a linked directory.");
        Equal("Normal.cs", enumerated[0], "Repository traversal did not retain the normal repository file.");
    }
    finally
    {
        Directory.Delete(root, recursive: true);
        Directory.Delete(outside, recursive: true);
    }

    return Task.CompletedTask;
}

static Task TestRepositoryPathPolicyExcludesKnownSecretsAndAppliesFilters()
{
    Equal(true, RepositoryPathPolicy.IsIgnoredRelativePath(".env"), "Repository path policy did not exclude .env.");
    Equal(true, RepositoryPathPolicy.IsIgnoredRelativePath("config/.env.local"), "Repository path policy did not exclude environment-specific secrets.");
    Equal(true, RepositoryPathPolicy.IsIgnoredRelativePath("infra/secrets.yaml"), "Repository path policy did not exclude a known secret manifest.");
    Equal(true, RepositoryPathPolicy.IsIgnoredRelativePath("cloud/service-account-prod.json"), "Repository path policy did not exclude service-account material.");
    Equal(true, RepositoryPathPolicy.IsIgnoredRelativePath("keys/deploy.pem"), "Repository path policy did not exclude a private-key extension.");
    Equal(true, RepositoryPathPolicy.IsIgnoredRelativePath("state/app.tfstate.backup"), "Repository path policy did not exclude Terraform state backup.");
    Equal(false, RepositoryPathPolicy.IsIgnoredRelativePath(".env.example"), "Repository path policy excluded a safe environment template.");
    Equal(false, RepositoryPathPolicy.IsIgnoredRelativePath("config/.env.production.template"), "Repository path policy excluded an environment-specific safe template.");
    Equal(false, RepositoryPathPolicy.IsIgnoredRelativePath("src/Secrets.cs"), "Repository path policy excluded source code based only on its name.");

    var filter = new RepositoryPathFilter(
        AllowPatterns: ["src/**"],
        DenyPatterns: ["src/generated/**"]);
    Equal(false, RepositoryPathPolicy.IsIgnoredRelativePath("src/App.cs", filter), "Repository path allow pattern did not include matching source.");
    Equal(true, RepositoryPathPolicy.IsIgnoredRelativePath("tests/AppTests.cs", filter), "Repository path allow pattern did not exclude a non-matching path.");
    Equal(true, RepositoryPathPolicy.IsIgnoredRelativePath("src/generated/App.g.cs", filter), "Repository path deny pattern did not override the allow pattern.");
    Equal(true, RepositoryPathPolicy.IsIgnoredRelativePath("src/.env", filter), "Allow pattern bypassed default known-secret exclusion.");

    var rootOnly = new RepositoryPathFilter(AllowPatterns: ["README.md"]);
    Equal(false, RepositoryPathPolicy.IsIgnoredRelativePath("README.md", rootOnly), "Root-relative allow pattern did not match the root file.");
    Equal(true, RepositoryPathPolicy.IsIgnoredRelativePath("docs/README.md", rootOnly), "Root-relative allow pattern matched a nested basename.");
    var recursiveBasename = new RepositoryPathFilter(AllowPatterns: ["**/README.md"]);
    Equal(false, RepositoryPathPolicy.IsIgnoredRelativePath("docs/README.md", recursiveBasename), "Recursive basename allow pattern did not match a nested file.");

    var explicitSecretOverride = filter with { ExcludeKnownSecretFiles = false };
    Equal(false, RepositoryPathPolicy.IsIgnoredRelativePath("src/.env", explicitSecretOverride), "Explicit known-secret override did not change the default exclusion.");
    Equal(true, RepositoryPathPolicy.IsIgnoredRelativePath("src/bin/Generated.cs", explicitSecretOverride), "Explicit secret override bypassed immutable generated-directory exclusions.");

    Equal(
        RepositoryPathPolicy.StableFingerprint(new RepositoryPathFilter(["SRC/**", "docs/**"])),
        RepositoryPathPolicy.StableFingerprint(new RepositoryPathFilter(["docs/**", "src/**"])),
        "Equivalent path filters produced different stable fingerprints.");

    return Task.CompletedTask;
}

static Task TestRepositoryPathPolicyRejectsUnsafePatterns()
{
    Throws<ArgumentException>(
        () => RepositoryPathPolicy.StableFingerprint(new RepositoryPathFilter(["../outside/**"])),
        "Repository path policy accepted parent traversal in an allow pattern.");
    Throws<ArgumentException>(
        () => RepositoryPathPolicy.StableFingerprint(new RepositoryPathFilter(DenyPatterns: [Path.GetFullPath("outside/**")])),
        "Repository path policy accepted an absolute deny pattern.");
    Throws<ArgumentException>(
        () => RepositoryPathPolicy.StableFingerprint(new RepositoryPathFilter(DenyPatterns: ["C:\\outside\\**"])),
        "Repository path policy accepted a Windows absolute deny pattern.");
    Throws<ArgumentException>(
        () => RepositoryPathPolicy.StableFingerprint(new RepositoryPathFilter([" "])),
        "Repository path policy accepted an empty allow pattern.");
    Throws<ArgumentException>(
        () => RepositoryPathPolicy.StableFingerprint(new RepositoryPathFilter(["src//**"])),
        "Repository path policy accepted an ambiguous repeated separator.");

    return Task.CompletedTask;
}

static Task TestEnvironmentFileLoaderFillsMissingVariables()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-env-loader-test-{Guid.NewGuid():N}");
    var missingKey = $"CODEMESH_TEST_ENV_MISSING_{Guid.NewGuid():N}";
    var quotedKey = $"CODEMESH_TEST_ENV_QUOTED_{Guid.NewGuid():N}";
    var existingKey = $"CODEMESH_TEST_ENV_EXISTING_{Guid.NewGuid():N}";

    try
    {
        Directory.CreateDirectory(root);
        File.WriteAllLines(
            Path.Combine(root, ".env"),
            [
                "# comment",
                $"{missingKey}=from-env-file",
                $"{quotedKey}=\"quoted value\"",
                $"{existingKey}=from-env-file"
            ]);

        Environment.SetEnvironmentVariable(missingKey, null);
        Environment.SetEnvironmentVariable(quotedKey, null);
        Environment.SetEnvironmentVariable(existingKey, "already-set");

        var loaded = EnvironmentFileLoader.LoadIfExists(root);

        Equal(2, loaded, "Environment loader loaded an unexpected number of variables.");
        Equal("from-env-file", Environment.GetEnvironmentVariable(missingKey) ?? string.Empty, "Environment loader did not set a missing variable.");
        Equal("quoted value", Environment.GetEnvironmentVariable(quotedKey) ?? string.Empty, "Environment loader did not unquote a value.");
        Equal("already-set", Environment.GetEnvironmentVariable(existingKey) ?? string.Empty, "Environment loader overwrote an existing variable.");
    }
    finally
    {
        Environment.SetEnvironmentVariable(missingKey, null);
        Environment.SetEnvironmentVariable(quotedKey, null);
        Environment.SetEnvironmentVariable(existingKey, null);

        if (Directory.Exists(root))
        {
            Directory.Delete(root, recursive: true);
        }
    }

    return Task.CompletedTask;
}

static Task TestIngestPathResolverAcceptsRelativeFiles()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-ingest-path-test-{Guid.NewGuid():N}");
    var solution = Path.Combine(root, "src", "Sample.sln");

    try
    {
        Directory.CreateDirectory(Path.GetDirectoryName(solution)!);
        File.WriteAllText(solution, string.Empty);

        Equal(
            solution,
            CodeMeshIngestPathResolver.ResolveFile(root, Path.Combine("src", "Sample.sln"), "Solution") ?? string.Empty,
            "Ingest path resolver did not resolve a repository-relative solution.");

        var callerRelativePath = Path.GetRelativePath(Directory.GetCurrentDirectory(), solution);
        Equal(
            solution,
            CodeMeshIngestPathResolver.ResolveFile(root, callerRelativePath, "Solution") ?? string.Empty,
            "Ingest path resolver did not resolve a caller-relative solution.");

        Equal(
            solution,
            CodeMeshIngestPathResolver.ResolveFile(root, solution, "Solution") ?? string.Empty,
            "Ingest path resolver changed an absolute solution path.");
    }
    finally
    {
        if (Directory.Exists(root))
        {
            Directory.Delete(root, recursive: true);
        }
    }

    return Task.CompletedTask;
}

static Task TestIngestPathResolverRejectsMissingFiles()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-ingest-path-missing-test-{Guid.NewGuid():N}");

    try
    {
        Directory.CreateDirectory(root);
        Throws<InvalidOperationException>(
            () => CodeMeshIngestPathResolver.ResolveFile(root, "missing.sln", "Solution"),
            "Ingest path resolver accepted a missing explicit solution.");
    }
    finally
    {
        if (Directory.Exists(root))
        {
            Directory.Delete(root, recursive: true);
        }
    }

    return Task.CompletedTask;
}

static Task TestRefreshWorkflowResolvesRepositoryRoot()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-refresh-root-test-{Guid.NewGuid():N}");
    var nested = Path.Combine(root, "src", "Nested");
    var solution = Path.Combine(root, "Sample.sln");

    try
    {
        Directory.CreateDirectory(nested);
        File.WriteAllText(solution, string.Empty);

        var target = CodeMeshRefreshWorkflow.ResolveTarget(nested);

        Equal(root, target.RootPath, "Refresh workflow did not walk up to the repository root.");
        Equal(solution, target.SolutionPath ?? string.Empty, "Refresh workflow did not default to the repository solution.");
    }
    finally
    {
        if (Directory.Exists(root))
        {
            Directory.Delete(root, recursive: true);
        }
    }

    return Task.CompletedTask;
}

static Task TestRefreshWorkflowNormalizesIngestArguments()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-refresh-args-test-{Guid.NewGuid():N}");
    var solution = Path.Combine(root, "Sample.sln");

    try
    {
        Directory.CreateDirectory(root);
        File.WriteAllText(solution, string.Empty);

        var target = CodeMeshRefreshWorkflow.ResolveTarget(root);
        var args = CodeMeshRefreshWorkflow.BuildRefreshIngestArgs(
            [
                "refresh",
                "--root",
                "ignored",
                "--solution",
                "ignored.sln",
                "--skip-embeddings",
                "--force-embeddings",
                "--include-summaries",
                "--summary-max-completion-tokens",
                "1024",
                "--json"
            ],
            target);

        Equal("ingest", args[0], "Refresh workflow did not normalize to the ingest command.");
        Equal(false, args.Contains("refresh"), "Refresh workflow leaked the refresh command into ingest args.");
        Equal(true, args.Contains("--skip-embeddings"), "Refresh workflow removed an ingestion flag.");
        Equal(true, args.Contains("--force-embeddings"), "Refresh workflow removed an embedding flag.");
        Equal(true, args.Contains("--include-summaries"), "Refresh workflow removed a summary flag.");
        Equal(true, args.Contains("--summary-max-completion-tokens"), "Refresh workflow removed summary budget configuration.");
        Equal("1024", args[Array.IndexOf(args, "--summary-max-completion-tokens") + 1], "Refresh workflow changed summary budget configuration.");
        Equal(true, args.Contains("--json"), "Refresh workflow removed json output flag.");
        Equal(1, args.Count(arg => string.Equals(arg, "--root", StringComparison.OrdinalIgnoreCase)), "Refresh workflow emitted duplicate root options.");
        Equal(1, args.Count(arg => string.Equals(arg, "--solution", StringComparison.OrdinalIgnoreCase)), "Refresh workflow emitted duplicate solution options.");
        Equal(root, args[Array.LastIndexOf(args, "--root") + 1], "Refresh workflow did not inject the resolved root.");
        Equal(solution, args[Array.LastIndexOf(args, "--solution") + 1], "Refresh workflow did not inject the resolved solution.");
    }
    finally
    {
        if (Directory.Exists(root))
        {
            Directory.Delete(root, recursive: true);
        }
    }

    return Task.CompletedTask;
}

static Task TestWatchWorkflowNormalizesRefreshArguments()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-watch-args-test-{Guid.NewGuid():N}");
    var solution = Path.Combine(root, "Sample.sln");

    try
    {
        Directory.CreateDirectory(root);
        File.WriteAllText(solution, string.Empty);

        var target = CodeMeshRefreshWorkflow.ResolveTarget(root);
        var args = CodeMeshWatchWorkflow.BuildWatchRefreshArgs(
            [
                "watch",
                "--root",
                "ignored",
                "--solution",
                "ignored.sln",
                "--poll-seconds",
                "1",
                "--max-runs",
                "2",
                "--run-once",
                "--skip-embeddings",
                "--include-summaries",
                "--summary-reasoning-token-reserve",
                "768",
                "--json"
            ],
            target);

        Equal("ingest", args[0], "Watch workflow did not normalize to the ingest command.");
        Equal(false, args.Contains("watch"), "Watch workflow leaked the watch command into ingest args.");
        Equal(false, args.Contains("--poll-seconds"), "Watch workflow leaked poll configuration into ingest args.");
        Equal(false, args.Contains("--max-runs"), "Watch workflow leaked run limit configuration into ingest args.");
        Equal(false, args.Contains("--run-once"), "Watch workflow leaked run-once configuration into ingest args.");
        Equal(true, args.Contains("--skip-embeddings"), "Watch workflow removed an ingestion flag.");
        Equal(true, args.Contains("--include-summaries"), "Watch workflow removed a summary flag.");
        Equal(true, args.Contains("--summary-reasoning-token-reserve"), "Watch workflow removed summary reasoning configuration.");
        Equal("768", args[Array.IndexOf(args, "--summary-reasoning-token-reserve") + 1], "Watch workflow changed summary reasoning configuration.");
        Equal(true, args.Contains("--json"), "Watch workflow removed json output flag.");
        Equal(root, args[Array.LastIndexOf(args, "--root") + 1], "Watch workflow did not inject the resolved root.");
        Equal(solution, args[Array.LastIndexOf(args, "--solution") + 1], "Watch workflow did not inject the resolved solution.");
    }
    finally
    {
        if (Directory.Exists(root))
        {
            Directory.Delete(root, recursive: true);
        }
    }

    return Task.CompletedTask;
}

static Task TestWatchWorkflowDetectsFileChanges()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-watch-snapshot-test-{Guid.NewGuid():N}");
    var file = Path.Combine(root, "src", "Sample.cs");
    var ignoredDirectory = Path.Combine(root, "bin");
    var ignoredTemporaryDirectory = Path.Combine(root, ".tmp");
    var ignoredSmokeDirectory = Path.Combine(root, ".codemesh-smoke");
    var filteredDirectory = Path.Combine(root, "tests");
    var secretFile = Path.Combine(root, ".env");

    try
    {
        Directory.CreateDirectory(Path.GetDirectoryName(file)!);
        Directory.CreateDirectory(ignoredDirectory);
        Directory.CreateDirectory(ignoredTemporaryDirectory);
        Directory.CreateDirectory(ignoredSmokeDirectory);
        Directory.CreateDirectory(filteredDirectory);
        File.WriteAllText(file, "one");

        var first = CodeMeshWatchWorkflow.CreateSnapshot(root);
        var unchanged = CodeMeshWatchWorkflow.CreateSnapshot(root);

        File.WriteAllText(file, "one two");
        var changed = CodeMeshWatchWorkflow.CreateSnapshot(root);

        File.WriteAllText(Path.Combine(ignoredDirectory, "Generated.cs"), "ignored");
        File.WriteAllText(Path.Combine(ignoredTemporaryDirectory, "Temporary.cs"), "ignored");
        File.WriteAllText(Path.Combine(ignoredSmokeDirectory, "Fixture.cs"), "ignored");
        var ignoredChange = CodeMeshWatchWorkflow.CreateSnapshot(root);

        Equal(false, CodeMeshWatchWorkflow.HasChanges(first, unchanged), "Watch workflow reported changes for identical snapshots.");
        Equal(true, CodeMeshWatchWorkflow.HasChanges(first, changed), "Watch workflow did not detect a changed file.");
        Equal(false, CodeMeshWatchWorkflow.HasChanges(changed, ignoredChange), "Watch workflow did not ignore generated directories.");

        var filter = new RepositoryPathFilter(AllowPatterns: ["src/**"]);
        File.WriteAllText(secretFile, "TOKEN=not-a-real-secret");
        File.WriteAllText(Path.Combine(filteredDirectory, "SampleTests.cs"), "one");
        var filtered = CodeMeshWatchWorkflow.CreateSnapshot(root, filter);
        File.WriteAllText(secretFile, "TOKEN=still-not-a-real-secret");
        File.WriteAllText(Path.Combine(filteredDirectory, "SampleTests.cs"), "one two");
        var filteredIgnoredChange = CodeMeshWatchWorkflow.CreateSnapshot(root, filter);
        Equal(false, CodeMeshWatchWorkflow.HasChanges(filtered, filteredIgnoredChange), "Watch workflow reacted to secret or allow-filtered files.");

        File.WriteAllText(file, "one two three");
        var filteredSourceChange = CodeMeshWatchWorkflow.CreateSnapshot(root, filter);
        Equal(true, CodeMeshWatchWorkflow.HasChanges(filteredIgnoredChange, filteredSourceChange), "Watch workflow missed an allowed source change.");
    }
    finally
    {
        if (Directory.Exists(root))
        {
            Directory.Delete(root, recursive: true);
        }
    }

    return Task.CompletedTask;
}

static Task TestSelfWorkflowResolvesRepositoryRoot()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-self-root-test-{Guid.NewGuid():N}");
    var nested = Path.Combine(root, "src", "Nested");
    var solution = Path.Combine(root, CodeMeshSelfWorkflow.SolutionFileName);

    try
    {
        Directory.CreateDirectory(nested);
        File.WriteAllText(solution, string.Empty);
        File.WriteAllText(Path.Combine(root, CodeMeshSelfWorkflow.MarkerFileName), "version: test");

        var target = CodeMeshSelfWorkflow.ResolveTarget(nested);

        Equal(root, target.RootPath, "Self workflow did not walk up to the CodeMesh repository root.");
        Equal(solution, target.SolutionPath, "Self workflow did not default to CodeMesh.sln.");
    }
    finally
    {
        if (Directory.Exists(root))
        {
            Directory.Delete(root, recursive: true);
        }
    }

    return Task.CompletedTask;
}

static Task TestSelfWorkflowNormalizesIngestArguments()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-self-args-test-{Guid.NewGuid():N}");
    var solution = Path.Combine(root, CodeMeshSelfWorkflow.SolutionFileName);
    var alternateSolution = Path.Combine(root, "Alternate.sln");

    try
    {
        Directory.CreateDirectory(root);
        File.WriteAllText(solution, string.Empty);
        File.WriteAllText(alternateSolution, string.Empty);
        File.WriteAllText(Path.Combine(root, CodeMeshSelfWorkflow.AgentInstructionsFileName), "# test");

        var target = CodeMeshSelfWorkflow.ResolveTarget(root, alternateSolution);
        var args = CodeMeshSelfWorkflow.BuildSelfIngestArgs(
            [
                "self",
                "smoke",
                "--root",
                "ignored",
                "--solution",
                "ignored.sln",
                "--agent-access-url",
                "http://127.0.0.1:8088",
                "--query",
                "ignored query",
                "--skip-embeddings",
                "--include-summaries",
                "--summary-max-input-chars",
                "4000",
                "--json"
            ],
            target);

        Equal("ingest", args[0], "Self workflow did not normalize to the ingest command.");
        Equal(false, args.Contains("smoke"), "Self workflow leaked the self smoke subcommand into ingest args.");
        Equal(false, args.Contains("--agent-access-url"), "Self workflow leaked smoke-only Agent Access options into ingest args.");
        Equal(true, args.Contains("--skip-embeddings"), "Self workflow removed an ingestion flag.");
        Equal(true, args.Contains("--include-summaries"), "Self workflow removed a summary flag.");
        Equal(true, args.Contains("--summary-max-input-chars"), "Self workflow removed summary input configuration.");
        Equal("4000", args[Array.IndexOf(args, "--summary-max-input-chars") + 1], "Self workflow changed summary input configuration.");
        Equal(true, args.Contains("--json"), "Self workflow removed json output flag.");
        Equal(root, args[Array.LastIndexOf(args, "--root") + 1], "Self workflow did not inject the resolved root.");
        Equal(alternateSolution, args[Array.LastIndexOf(args, "--solution") + 1], "Self workflow did not inject the resolved solution.");
    }
    finally
    {
        if (Directory.Exists(root))
        {
            Directory.Delete(root, recursive: true);
        }
    }

    return Task.CompletedTask;
}

static Task TestSelfWorkflowRejectsInvalidRoots()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-self-invalid-test-{Guid.NewGuid():N}");

    try
    {
        Directory.CreateDirectory(root);
        Throws<InvalidOperationException>(
            () => CodeMeshSelfWorkflow.ResolveTarget(root),
            "Self workflow accepted a directory without CodeMesh root markers.");
    }
    finally
    {
        if (Directory.Exists(root))
        {
            Directory.Delete(root, recursive: true);
        }
    }

    return Task.CompletedTask;
}

static Task TestAgentAccessContractsMapRestJson()
{
    var options = new JsonSerializerOptions(JsonSerializerDefaults.Web);
    var serializedQuery = JsonSerializer.Serialize(
        new AgentContextQuery(
            "DownloadAsync",
            RepositoryId: "repo:test",
            Kinds: ["Method"],
            Filters: new Dictionary<string, string> { ["project"] = "Sample" },
            Vector: [0.1f, 0.2f],
            ExpandContext: false,
            ContextRelationshipLimit: 4),
        options);

    if (!serializedQuery.Contains("\"repository_id\":\"repo:test\"", StringComparison.Ordinal) ||
        !serializedQuery.Contains("\"context_relationship_limit\":4", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("Agent context query did not serialize using Agent Access snake_case fields.");
    }

    var serializedPackageQuery = JsonSerializer.Serialize(
        new AgentContextPackageQuery(
            "DownloadAsync",
            RepositoryId: "repo:test",
            MaxCharacters: 4000,
            CallerLimit: 2,
            UsesTypeLimit: 0),
        options);

    if (!serializedPackageQuery.Contains("\"max_characters\":4000", StringComparison.Ordinal) ||
        !serializedPackageQuery.Contains("\"uses_type_limit\":0", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("Agent context package query did not serialize using Agent Access snake_case fields.");
    }

    var context = JsonSerializer.Deserialize<AgentContextResult>(
        """
        {
          "query": {
            "query": "DownloadAsync",
            "repository_id": "repo:test",
            "limit": 5,
            "kinds": ["Method"],
            "filters": {"project": "Sample"},
            "vector": [0.1, 0.2],
            "expand_context": false,
            "context_depth": 2,
            "include_context_relationships": true,
            "context_relationship_limit": 4
          },
          "hits": [
            {
              "node_id": "node:download",
              "stable_key": "stable:download",
              "kind": "Method",
              "file_path": "Downloader.cs",
              "start_line": 10,
              "end_line": 20,
              "score": 0.91,
              "repository_id": "repo:test",
              "content_hash": "content:download",
              "score_components": {"vector_score": 0.6},
              "expanded_context": {"reason": "defined_ancestor"},
              "preview": "Task DownloadAsync"
            }
          ],
          "diagnostics": {
            "mode": "hybrid",
            "embedding_attempted": true,
            "embedding_source": "model_provider",
            "model_provider": "lmstudio",
            "vector_available": true,
            "vector_hit_count": 7,
            "lexical_hit_count": 3,
            "summary_hit_count": 2,
            "vector_candidate_count": 9,
            "lexical_candidate_count": 5,
            "summary_candidate_count": 4,
            "lexical_fallback": false,
            "hit_count": 1
          },
          "generated_at": "2026-06-06T10:00:00Z"
        }
        """,
        options);

    NotNull(context, "Agent context result did not deserialize.");
    Equal("repo:test", context!.Query.RepositoryId ?? string.Empty, "Agent context query repository id did not map from snake_case.");
    Equal(false, context.Query.ExpandContext, "Agent context query expansion flag changed.");
    Equal(4, context.Query.ContextRelationshipLimit, "Agent context relationship limit did not deserialize.");
    Equal(CodeNodeKind.Method, context.Hits[0].Kind, "Agent context hit kind did not deserialize.");
    Equal("content:download", context.Hits[0].ContentHash ?? string.Empty, "Agent context hit content hash did not deserialize.");
    Equal(0.6, context.Hits[0].ScoreComponents!["vector_score"], "Agent context score components did not deserialize.");
    Equal("defined_ancestor", context.Hits[0].ExpandedContext!["reason"].GetString() ?? string.Empty, "Agent context expanded context did not deserialize.");
    Equal("hybrid", context.Diagnostics!.Mode, "Agent context diagnostics mode did not deserialize.");
    Equal("lmstudio", context.Diagnostics.ModelProvider, "Agent context diagnostics provider did not deserialize.");
    Equal(7, context.Diagnostics.VectorHitCount, "Agent context diagnostics vector hit count did not deserialize.");
    Equal(3, context.Diagnostics.LexicalHitCount, "Agent context diagnostics lexical hit count did not deserialize.");
    Equal(2, context.Diagnostics.SummaryHitCount, "Agent context diagnostics summary hit count did not deserialize.");
    Equal(9, context.Diagnostics.VectorCandidateCount, "Agent context diagnostics vector candidate count did not deserialize.");
    Equal(5, context.Diagnostics.LexicalCandidateCount, "Agent context diagnostics lexical candidate count did not deserialize.");
    Equal(4, context.Diagnostics.SummaryCandidateCount, "Agent context diagnostics summary candidate count did not deserialize.");

    var package = JsonSerializer.Deserialize<AgentContextPackageResult>(
        """
        {
          "query": {
            "query": "DownloadAsync",
            "repository_id": "repo:test",
            "limit": 3,
            "max_characters": 4000,
            "kinds": ["Method"],
            "filters": {"project": "Sample"},
            "vector": [0.1, 0.2],
            "context_depth": 3,
            "include_content": true,
            "include_relationships": true,
            "relationship_limit": 8,
            "caller_limit": 2,
            "callee_limit": 2,
            "read_limit": 1,
            "write_limit": 1,
            "contains_limit": 1,
            "definition_limit": 1,
            "uses_type_limit": 0,
            "include_repository": true
          },
          "repository": {"repository_id": "repo:test", "alias": "sample_repo"},
          "latest_run": {"run_id": "run:test", "embedding_provider": "lmstudio"},
          "items": [
            {
              "hit": {
                "node_id": "node:download",
                "stable_key": "stable:download",
                "kind": "Method",
                "file_path": "Downloader.cs",
                "start_line": 10,
                "end_line": 20,
                "score": 0.91
              },
              "node": {"id": "node:download", "kind": "Method"},
              "content": {"hash": "content:download"},
              "summary": {"summary": "Downloads subtitles for a video URL.", "provider": "test"},
              "snippet": "return Task.CompletedTask;",
              "relationships": [{"kind": "Invokes", "target_node_id": "node:callee"}],
              "relationship_groups": {
                "callees": [{"kind": "Invokes", "target_node_id": "node:callee"}],
                "callers": []
              },
              "rationale": {"rank": 1, "expanded": true}
            }
          ],
          "validation_recommendations": [
            {
              "id": "dotnet-tests",
              "command": "dotnet run --project tests/CodeMesh.Tests",
              "reason": "Run after .NET changes.",
              "applies_to": ["Downloader.cs"]
            }
          ],
          "total_snippet_characters": 26,
          "generated_at": "2026-06-06T10:00:00Z"
        }
        """,
        options);

    NotNull(package, "Agent context package did not deserialize.");
    Equal(4000, package!.Query.MaxCharacters, "Agent context package max characters did not deserialize.");
    Equal(0, package.Query.UsesTypeLimit ?? -1, "Agent context package uses type limit did not deserialize.");
    Equal("sample_repo", package.Repository!["alias"].GetString() ?? string.Empty, "Agent context package repository metadata did not deserialize.");
    Equal("lmstudio", package.LatestRun!["embedding_provider"].GetString() ?? string.Empty, "Agent context package latest run did not deserialize.");
    Equal("dotnet run --project tests/CodeMesh.Tests", package.ValidationRecommendations![0]["command"].GetString() ?? string.Empty, "Agent context package validation recommendations did not deserialize.");
    Equal("Downloads subtitles for a video URL.", package.Items[0].Summary!["summary"].GetString() ?? string.Empty, "Agent context package summary did not deserialize.");
    Equal("return Task.CompletedTask;", package.Items[0].Snippet ?? string.Empty, "Agent context package snippet did not deserialize.");
    Equal("node:callee", package.Items[0].RelationshipGroups!["callees"][0]["target_node_id"].GetString() ?? string.Empty, "Agent context package relationship groups did not deserialize.");
    Equal(1, package.Items[0].Rationale!["rank"].GetInt32(), "Agent context package rationale did not deserialize.");

    return Task.CompletedTask;
}

static async Task TestAgentAccessClientCallsRestEndpoints()
{
    var handler = new FakeAgentAccessHandler();
    using var http = new HttpClient(handler)
    {
        BaseAddress = new Uri("http://agent.test/")
    };
    var client = new AgentAccessClient(http);

    var health = await client.GetHealthAsync();
    Equal("health", handler.Requests[0].Path, "Agent Access health path changed.");
    Equal("healthy", health.Status, "Agent Access health status did not deserialize.");
    Equal("healthy", health.Components["model_provider"].GetProperty("status").GetString() ?? string.Empty, "Agent Access health components did not deserialize.");

    var status = await client.GetStatusAsync();
    Equal("status", handler.Requests[1].Path, "Agent Access status path changed.");
    Equal("codemesh-agent-access", status.Service, "Agent Access status service did not deserialize.");

    var context = await client.SearchContextAsync(new AgentContextQuery(
        "DownloadAsync",
        RepositoryId: "repo:test",
        Kinds: ["Method"],
        Filters: new Dictionary<string, string> { ["project"] = "Sample" },
        Vector: [0.1f, 0.2f],
        IncludeContextRelationships: true));

    Equal("context/search", handler.Requests[2].Path, "Agent Access context search path changed.");
    if (!handler.Requests[2].Body.Contains("\"repository_id\":\"repo:test\"", StringComparison.Ordinal) ||
        !handler.Requests[2].Body.Contains("\"include_context_relationships\":true", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("Agent Access context request did not use REST JSON field names.");
    }

    Equal("hybrid", context.Diagnostics!.Mode, "Agent Access context response diagnostics changed.");
    Equal("node:download", context.Hits[0].NodeId, "Agent Access context hit did not deserialize.");

    var package = await client.GetContextPackageAsync(new AgentContextPackageQuery(
        "DownloadAsync",
        RepositoryId: "repo:test",
        MaxCharacters: 4000,
        CallerLimit: 2));

    Equal("context/package", handler.Requests[3].Path, "Agent Access context package path changed.");
    if (!handler.Requests[3].Body.Contains("\"max_characters\":4000", StringComparison.Ordinal) ||
        !handler.Requests[3].Body.Contains("\"caller_limit\":2", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("Agent Access package request did not use REST JSON field names.");
    }

    if (handler.Requests[3].Body.Contains("\"vector\":null", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("Agent Access package request should omit null vectors.");
    }

    Equal("return Task.CompletedTask;", package.Items[0].Snippet ?? string.Empty, "Agent Access package response did not deserialize.");

    var symbols = await client.SearchSymbolsAsync(new AgentSymbolQuery(
        "DownloadAsync",
        RepositoryId: "repo:test",
        Kinds: ["Method"],
        IncludeDeclarations: false));

    Equal("symbols/search", handler.Requests[4].Path, "Agent Access symbol search path changed.");
    Equal("DownloadAsync", symbols.Symbols[0].Node["name"].GetString() ?? string.Empty, "Agent Access symbol result did not deserialize.");

    var node = await client.GetNodeAsync(new AgentNodeLookup(
        "node:download",
        RepositoryId: "repo:test",
        IncludeContent: false));

    Equal("nodes/get", handler.Requests[5].Path, "Agent Access node path changed.");
    Equal("node:download", node.Node!["id"].GetString() ?? string.Empty, "Agent Access node result did not deserialize.");

    var neighbors = await client.GetNeighborsAsync(new AgentNeighborQuery(
        "node:download",
        RepositoryId: "repo:test",
        RelationshipKinds: ["Invokes"]));

    Equal("graph/neighbors", handler.Requests[6].Path, "Agent Access neighbors path changed.");
    Equal("node:download", neighbors.Node!["id"].GetString() ?? string.Empty, "Agent Access neighbor node did not deserialize.");
    Equal("Invokes", neighbors.Relationships[0]["kind"].GetString() ?? string.Empty, "Agent Access neighbor result did not deserialize.");

    var repositories = await client.ListRepositoriesAsync(limit: 3);
    Equal("repositories?limit=3", handler.Requests[7].Path, "Agent Access repositories path changed.");
    Equal("sample_repo", repositories.Repositories[0].Alias ?? string.Empty, "Agent Access repository list did not deserialize.");
    Equal(17, repositories.Repositories[0].NodeCount, "Agent Access repository node count did not deserialize.");

    var repository = await client.GetRepositoryAsync("sample repo/id");
    Equal("repositories/sample%20repo%2Fid", handler.Requests[8].Path, "Agent Access repository lookup path did not escape id.");
    Equal("repo:test", repository!.RepositoryId, "Agent Access repository lookup did not deserialize.");

    var repositoryStatus = await client.GetRepositoryStatusAsync("sample repo/id");
    Equal("repositories/sample%20repo%2Fid/status", handler.Requests[9].Path, "Agent Access repository status path did not escape id.");
    Equal("repo:test", repositoryStatus.RepositoryId, "Agent Access repository status did not deserialize.");
    Equal("fresh", repositoryStatus.Freshness["status"].GetString() ?? string.Empty, "Agent Access repository freshness did not deserialize.");
    Equal("completed", repositoryStatus.Refresh["status"].GetString() ?? string.Empty, "Agent Access repository refresh status did not deserialize.");
    Equal("run:test", repositoryStatus.Refresh["latest_run_id"].GetString() ?? string.Empty, "Agent Access repository refresh run id did not deserialize.");
    Equal(17, repositoryStatus.Counts["graph_nodes"].GetInt32(), "Agent Access repository status counts did not deserialize.");

    var coverage = await client.GetSummaryCoverageAsync("sample repo/id");
    Equal("repositories/sample%20repo%2Fid/summaries", handler.Requests[10].Path, "Agent Access summary coverage path did not escape id.");
    Equal(5, coverage.CompletedCount, "Agent Access summary coverage completed count did not deserialize.");
    Equal(2, coverage.KindCounts["Method"], "Agent Access summary coverage kind counts did not deserialize.");
    Equal("qwen/qwen2.5-coder-14b", coverage.ProviderModelCountDetails[0].Model, "Agent Access summary coverage provider/model details did not deserialize.");
    Equal("model failed", coverage.RecentFailures[0]["error"].GetString() ?? string.Empty, "Agent Access summary coverage failures did not deserialize.");

    var runs = await client.ListIngestionRunsAsync(repositoryId: "sample repo/id", limit: 2);
    Equal("ingestion-runs?limit=2&repository_id=sample%20repo%2Fid", handler.Requests[11].Path, "Agent Access runs path changed.");
    Equal("run:test", runs.Runs[0].RunId, "Agent Access ingestion run did not deserialize.");
    Equal("lmstudio", runs.Runs[0].EmbeddingProvider, "Agent Access run embedding provider did not deserialize.");

    var delete = await client.DeleteRepositoryAsync("sample repo/id");
    Equal(HttpMethod.Delete.Method, handler.Requests[12].Method, "Agent Access repository delete method changed.");
    Equal("repositories/sample%20repo%2Fid", handler.Requests[12].Path, "Agent Access repository delete path did not escape id.");
    Equal("repo:test", delete.RepositoryId, "Agent Access repository delete response did not deserialize.");
    Equal(true, delete.Deleted, "Agent Access repository delete did not report deletion.");
    Equal(true, delete.SummariesCleaned, "Agent Access repository delete cleanup flags did not deserialize.");

    handler.FailNextRequest = true;
    try
    {
        await client.SearchContextAsync(new AgentContextQuery("DownloadAsync"));
    }
    catch (InvalidOperationException exception) when (
        exception.Message.Contains("context/search", StringComparison.Ordinal) &&
        exception.Message.Contains("HTTP 503", StringComparison.Ordinal))
    {
        return;
    }

    throw new InvalidOperationException("Agent Access client did not surface REST error details.");
}

static async Task TestIngestionWritesParserOutput()
{
    var store = new InMemoryCodeMeshStore();
    var parser = new FakeParserClient();
    var orchestrator = new IngestionOrchestrator(
        parser,
        store,
        store,
        store,
        new NoEmbeddingProvider());

    var result = await orchestrator.IngestAsync(new IngestionRequest(
        Directory.GetCurrentDirectory(),
        DryRun: false));

    Equal(1, result.NodeCount, "Expected one node from fake parser.");
    Equal(1, result.ContentCount, "Expected one content item from fake parser.");

    var node = await store.GetNodeAsync(FakeParserClient.NodeId);
    NotNull(node, "Node was not written to graph store.");

    var content = await store.GetContentAsync(FakeParserClient.ContentHash);
    NotNull(content, "Content was not written to content store.");
}

static async Task TestMultiLanguageIngestionPublishesOneDeterministicSnapshot()
{
    var store = new InMemoryCodeMeshStore();
    var parser = new CompositeParserClient(new Dictionary<string, IParserClient>
    {
        ["rust"] = new LanguageFixtureParserClient("rust", ".rs"),
        ["python"] = new LanguageFixtureParserClient("python", ".py")
    });
    var orchestrator = new IngestionOrchestrator(
        parser,
        store,
        store,
        store,
        new NoEmbeddingProvider());

    var first = await orchestrator.IngestAsync(new IngestionRequest(
        Directory.GetCurrentDirectory(),
        Language: "rust,python",
        DryRun: true));
    var second = await orchestrator.IngestAsync(new IngestionRequest(
        Directory.GetCurrentDirectory(),
        Language: "python,rust",
        DryRun: true));
    var filtered = await orchestrator.IngestAsync(new IngestionRequest(
        Directory.GetCurrentDirectory(),
        Language: "python,rust",
        DryRun: true,
        PathFilter: new RepositoryPathFilter(DenyPatterns: ["not-present/**"])));

    Equal(2, first.NodeCount, "Composite ingestion did not retain both parser outputs.");
    Equal(2, first.ContentCount, "Composite ingestion did not retain both source contents.");
    Equal(
        first.Repository.SnapshotId ?? string.Empty,
        second.Repository.SnapshotId ?? string.Empty,
        "Language order changed the atomic snapshot identity.");
    Equal(
        false,
        string.Equals(first.Repository.SnapshotId, filtered.Repository.SnapshotId, StringComparison.Ordinal),
        "Repository path filter did not change snapshot scope identity.");
}

static async Task TestIngestionRedactsSensitiveContentBeforeStoresAndEmbeddings()
{
    var store = new InMemoryCodeMeshStore();
    var parser = new SecretParserClient();
    var embeddingProvider = new CapturingEmbeddingProvider();
    var orchestrator = new IngestionOrchestrator(
        parser,
        store,
        store,
        store,
        embeddingProvider);

    var result = await orchestrator.IngestAsync(new IngestionRequest(
        Directory.GetCurrentDirectory(),
        SkipEmbeddings: false));

    Equal(1, result.ContentCount, "Redaction changed content count.");
    Equal(1, result.Diagnostics.Count(diagnostic => diagnostic.Code == "CMSEC001"), "Redaction diagnostic was not emitted.");

    var node = await store.GetNodeAsync(SecretParserClient.NodeId);
    NotNull(node, "Redacted node was not written.");
    var content = await store.GetContentAsync(node!.ContentHash);
    NotNull(content, "Redacted content was not written under the node content hash.");

    if (content!.Text.Contains(SecretParserClient.SecretValue, StringComparison.Ordinal) ||
        embeddingProvider.LastText.Contains(SecretParserClient.SecretValue, StringComparison.Ordinal))
    {
        throw new InvalidOperationException("Sensitive value reached persisted content or embedding input.");
    }

    if (!content.Text.Contains("<redacted>", StringComparison.Ordinal) ||
        !embeddingProvider.LastText.Contains("<redacted>", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("Sensitive value was not replaced with a redaction marker.");
    }

    Equal(node.ContentHash, content.Hash, "Node content hash was not remapped to the redacted content hash.");

    const string embeddedSecret = "cm_eval_not_a_real_secret_7f93d2";
    var embedded = ContentRedactor.RedactText(
        $"public const string Example = \"CODEMESH_EVAL_TOKEN={embeddedSecret}\";");
    if (embedded.Contains(embeddedSecret, StringComparison.Ordinal) ||
        !embedded.Contains("CODEMESH_EVAL_TOKEN=<redacted>", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("A sensitive key/value embedded in a quoted string was not redacted.");
    }
}

static async Task TestDryRunSkipsStores()
{
    var store = new InMemoryCodeMeshStore();
    var parser = new FakeParserClient();
    var orchestrator = new IngestionOrchestrator(
        parser,
        store,
        store,
        store,
        new NoEmbeddingProvider());

    var result = await orchestrator.IngestAsync(new IngestionRequest(
        Directory.GetCurrentDirectory(),
        DryRun: true));

    Equal(1, result.NodeCount, "Dry run should still parse nodes.");

    var node = await store.GetNodeAsync(FakeParserClient.NodeId);
    IsNull(node, "Dry run wrote to graph store.");

    var content = await store.GetContentAsync(FakeParserClient.ContentHash);
    IsNull(content, "Dry run wrote to content store.");
}

static async Task TestRepositoryRefreshRemovesStaleRecords()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-refresh-test-{Guid.NewGuid():N}");
    Directory.CreateDirectory(root);

    try
    {
        var store = new InMemoryCodeMeshStore();
        var parser = new RefreshParserClient("Alpha");
        var orchestrator = new IngestionOrchestrator(
            parser,
            store,
            store,
            store,
            new DeterministicEmbeddingProvider());
        var repositoryId = CodeMeshHash.StableId(Path.GetFullPath(root));

        await orchestrator.IngestAsync(new IngestionRequest(
            root,
            DryRun: false,
            SkipEmbeddings: false));

        var alphaNode = await store.GetNodeAsync(RefreshParserClient.NodeIdFor("Alpha"));
        NotNull(alphaNode, "Initial refresh ingest did not write Alpha node.");
        Equal(repositoryId, alphaNode!.Metadata["repositoryId"], "Repository id metadata was not stamped.");
        NotNull(await store.GetContentAsync(RefreshParserClient.ContentHashFor("Alpha")), "Initial refresh ingest did not write Alpha content.");

        parser.TypeName = "Beta";
        await orchestrator.IngestAsync(new IngestionRequest(
            root,
            DryRun: false,
            SkipEmbeddings: false));

        IsNull(await store.GetNodeAsync(RefreshParserClient.NodeIdFor("Alpha")), "Refresh did not remove stale Alpha node.");
        IsNull(await store.GetContentAsync(RefreshParserClient.ContentHashFor("Alpha")), "Refresh did not remove stale Alpha content.");
        NotNull(await store.GetNodeAsync(RefreshParserClient.NodeIdFor("Beta")), "Refresh did not keep current Beta node.");
        NotNull(await store.GetContentAsync(RefreshParserClient.ContentHashFor("Beta")), "Refresh did not keep current Beta content.");

        var matches = await store.SearchAsync(
            [1.0f, 0.0f],
            10,
            new Dictionary<string, string> { ["repositoryId"] = repositoryId });
        if (matches.Any(match => string.Equals(match.NodeId, RefreshParserClient.NodeIdFor("Alpha"), StringComparison.Ordinal)))
        {
            throw new InvalidOperationException("Refresh did not remove stale Alpha embedding.");
        }

        if (!matches.Any(match => string.Equals(match.NodeId, RefreshParserClient.NodeIdFor("Beta"), StringComparison.Ordinal)))
        {
            throw new InvalidOperationException("Refresh did not keep current Beta embedding.");
        }
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static async Task TestIncrementalIngestionSkipsUnchangedRecords()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-incremental-test-{Guid.NewGuid():N}");
    Directory.CreateDirectory(root);

    try
    {
        var store = new InMemoryCodeMeshStore();
        var parser = new RefreshParserClient("Alpha");
        var embeddingProvider = new CountingEmbeddingProvider();
        var orchestrator = new IngestionOrchestrator(
            parser,
            store,
            store,
            store,
            embeddingProvider);

        var first = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            DryRun: false,
            SkipEmbeddings: false));

        NotNull(first.Stats, "Initial ingest did not report stats.");
        Equal(1, first.Stats!.WrittenNodeCount, "Initial ingest did not write the parsed node.");
        Equal(0, first.Stats.SkippedNodeCount, "Initial ingest incorrectly skipped a node.");
        Equal(1, first.Stats.WrittenContentCount, "Initial ingest did not write content.");
        Equal(1, first.Stats.WrittenEmbeddingCount, "Initial ingest did not write an embedding.");
        Equal(1, embeddingProvider.EmbeddedNodeCount, "Initial ingest did not call embedding provider for the parsed node.");

        var second = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            DryRun: false,
            SkipEmbeddings: false));

        NotNull(second.Stats, "Incremental ingest did not report stats.");
        Equal(1, second.Stats!.ParsedNodeCount, "Incremental ingest parsed node count changed.");
        Equal(0, second.Stats.WrittenNodeCount, "Incremental ingest rewrote an unchanged node.");
        Equal(1, second.Stats.SkippedNodeCount, "Incremental ingest did not skip the unchanged node.");
        Equal(0, second.Stats.WrittenContentCount, "Incremental ingest rewrote unchanged content.");
        Equal(1, second.Stats.SkippedContentCount, "Incremental ingest did not skip unchanged content.");
        Equal(0, second.Stats.WrittenEmbeddingCount, "Incremental ingest regenerated an unchanged embedding.");
        Equal(1, second.Stats.SkippedEmbeddingCount, "Incremental ingest did not skip the unchanged embedding.");
        Equal(1, embeddingProvider.EmbeddedNodeCount, "Incremental ingest called embedding provider for an unchanged node.");
        NotNull(await store.GetNodeAsync(RefreshParserClient.NodeIdFor("Alpha")), "Incremental cleanup removed an unchanged node.");
        NotNull(await store.GetContentAsync(RefreshParserClient.ContentHashFor("Alpha")), "Incremental cleanup removed unchanged content.");

        parser.TypeName = "Beta";
        var third = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            DryRun: false,
            SkipEmbeddings: false));

        NotNull(third.Stats, "Changed incremental ingest did not report stats.");
        Equal(1, third.Stats!.WrittenNodeCount, "Changed incremental ingest did not write the new node.");
        Equal(0, third.Stats.SkippedNodeCount, "Changed incremental ingest incorrectly skipped the new node.");
        Equal(2, embeddingProvider.EmbeddedNodeCount, "Changed incremental ingest did not embed the changed node.");
        IsNull(await store.GetNodeAsync(RefreshParserClient.NodeIdFor("Alpha")), "Incremental cleanup did not remove stale Alpha node.");
        NotNull(await store.GetNodeAsync(RefreshParserClient.NodeIdFor("Beta")), "Incremental cleanup did not keep current Beta node.");
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static async Task TestIncrementalIngestionSkipsUnchangedSummaries()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-summary-test-{Guid.NewGuid():N}");
    Directory.CreateDirectory(root);

    try
    {
        var store = new InMemoryCodeMeshStore();
        var parser = new RefreshParserClient("Alpha");
        var summaryProvider = new CountingSummaryProvider();
        var orchestrator = new IngestionOrchestrator(
            parser,
            store,
            store,
            store,
            new NoEmbeddingProvider(),
            summaryStore: store,
            summaryProvider: summaryProvider);
        var repositoryId = CodeMeshHash.StableId(Path.GetFullPath(root));

        var first = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            DryRun: false,
            IncludeSummaries: true));

        Equal(1, first.SummaryCount, "Initial ingest did not write a summary.");
        Equal(1, first.Stats?.SummaryCandidateCount ?? -1, "Initial ingest summary candidate count changed.");
        Equal(1, first.Stats?.WrittenSummaryCount ?? -1, "Initial ingest did not report a written summary.");
        Equal(1, summaryProvider.SummarizedNodeCount, "Initial ingest did not call summary provider.");

        var states = await store.GetSummaryStatesAsync(repositoryId);
        Equal(1, states.Count, "Summary store did not retain the generated summary.");
        Equal(RefreshParserClient.NodeIdFor("Alpha"), states[0].NodeId, "Summary state node id changed.");
        var coverage = await store.GetSummaryCoverageAsync(repositoryId);
        Equal(1, coverage.TotalCount, "Summary coverage total count changed.");
        Equal(1, coverage.CompletedCount, "Summary coverage completed count changed.");
        Equal(0, coverage.FailedCount, "Summary coverage failed count changed.");
        Equal(1, coverage.KindCounts["Class"], "Summary coverage kind count changed.");
        Equal(1, coverage.ProviderModelCounts["test/summary-counting/node-summary-v2"], "Summary coverage provider/model count changed.");
        Equal("summary-counting", coverage.ProviderModelCountDetails[0].Model, "Summary coverage provider/model detail changed.");

        await store.UpsertSummariesAsync([
            new CodeNodeSummary(
                CodeMeshHash.StableId(
                    "summary",
                    repositoryId,
                    RefreshParserClient.NodeIdFor("Alpha"),
                    states[0].ContentHash,
                    "symbol",
                    "other",
                    "other-model",
                    "node-summary-v1"),
                repositoryId,
                Path.GetFullPath(root),
                "run:other-summary",
                RefreshParserClient.NodeIdFor("Alpha"),
                RefreshParserClient.NodeIdFor("Alpha"),
                CodeNodeKind.Class,
                "Alpha",
                "csharp",
                "Sample",
                new SourceSpan("Alpha.cs", 1, 1, 1, 1),
                states[0].ContentHash,
                "symbol",
                "Alternate provider summary.",
                [],
                "high",
                "other",
                "other-model",
                "node-summary-v1",
                "alternate-provider-v1",
                CodeMeshHash.StableId("summary-prompt", "node-summary-v1"),
                DateTimeOffset.UtcNow,
                "completed",
                null,
                new Dictionary<string, string>())
        ]);

        var second = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            DryRun: false,
            IncludeSummaries: true));

        Equal(0, second.SummaryCount, "Unchanged ingest should not rewrite a summary.");
        Equal(0, second.Stats?.WrittenSummaryCount ?? -1, "Unchanged ingest rewrote a summary.");
        Equal(1, second.Stats?.SkippedSummaryCount ?? -1, "Unchanged ingest did not skip the existing summary.");
        Equal(1, summaryProvider.SummarizedNodeCount, "Unchanged ingest called summary provider again.");

        var forced = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            DryRun: false,
            IncludeSummaries: true,
            ForceSummaries: true));

        Equal(1, forced.SummaryCount, "Forced ingest did not rewrite summary.");
        Equal(1, forced.Stats?.WrittenSummaryCount ?? -1, "Forced ingest did not report a written summary.");
        Equal(0, forced.Stats?.SkippedSummaryCount ?? -1, "Forced ingest incorrectly skipped summary.");
        Equal(2, summaryProvider.SummarizedNodeCount, "Forced ingest did not call summary provider again.");
        coverage = await store.GetSummaryCoverageAsync(repositoryId);
        Equal(2, coverage.TotalCount, "Forced summary cleanup removed current summaries from another provider/model.");
        Equal(1, coverage.ProviderModelCounts["other/other-model/node-summary-v1"], "Forced summary cleanup did not keep alternate provider summary.");

        parser.TypeName = "Beta";
        var changedWithoutSummaries = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            DryRun: false,
            IncludeSummaries: false));

        Equal(0, changedWithoutSummaries.SummaryCount, "Summary-disabled changed ingest should not write summaries.");
        Equal(2, summaryProvider.SummarizedNodeCount, "Summary-disabled changed ingest called the summary provider.");
        coverage = await store.GetSummaryCoverageAsync(repositoryId);
        Equal(0, coverage.TotalCount, "Summary-disabled changed ingest did not remove stale summaries across providers.");
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static Task TestSummaryBudgetsScaleWithNodeComplexity()
{
    var compact = SummaryBudgetPolicy.CreateRequest(
        SummaryNode(
            CodeNodeKind.Property,
            "Name",
            "public string Name { get; init; }",
            startLine: 1,
            endLine: 1),
        SummaryContent("public string Name { get; init; }"),
        "node-summary-v2");
    Equal(SummaryComplexityTier.Compact, compact.Budget!.ComplexityTier, "A trivial property did not use the compact summary tier.");
    Equal(128, compact.Budget.VisibleTokenBudget, "Compact visible summary budget changed.");
    Equal(1024, compact.Budget.MaxCompletionTokens, "Compact completion ceiling changed.");

    var complexText = string.Join(
        Environment.NewLine,
        Enumerable.Range(1, 60).Select(index => $"DoWork({index});"));
    var complex = SummaryBudgetPolicy.CreateRequest(
        SummaryNode(
            CodeNodeKind.Method,
            "Run",
            complexText,
            startLine: 1,
            endLine: 60),
        SummaryContent(complexText),
        "node-summary-v2");
    Equal(SummaryComplexityTier.Complex, complex.Budget!.ComplexityTier, "A 60-line method did not use the complex summary tier.");
    Equal(320, complex.Budget.VisibleTokenBudget, "Complex visible summary budget changed.");
    Equal(1536, complex.Budget.MaxCompletionTokens, "Complex completion ceiling changed.");

    var aggregate = SummaryBudgetPolicy.CreateRequest(
        SummaryNode(
            CodeNodeKind.File,
            "Worker.cs",
            "sealed class Worker;",
            startLine: 1,
            endLine: 1),
        SummaryContent("sealed class Worker;"),
        "node-summary-v2");
    Equal(SummaryComplexityTier.Aggregate, aggregate.Budget!.ComplexityTier, "A file did not use the aggregate summary tier.");
    Equal(448, aggregate.Budget.VisibleTokenBudget, "Aggregate visible summary budget changed.");
    Equal(1536, aggregate.Budget.MaxCompletionTokens, "Aggregate completion ceiling changed.");

    var longText = new string('x', 4500);
    var capped = SummaryBudgetPolicy.CreateRequest(
        SummaryNode(
            CodeNodeKind.Method,
            "LongMethod",
            longText,
            startLine: 1,
            endLine: 20),
        SummaryContent(longText),
        "node-summary-v2",
        new SummaryBudgetPolicyOptions(
            MaxInputCharacters: 4000,
            ReasoningTokenReserve: 0,
            MaxCompletionTokens: 768));
    Equal(SummaryComplexityTier.Aggregate, capped.Budget!.ComplexityTier, "A truncated input did not use the aggregate summary tier.");
    Equal(true, capped.Budget.InputTruncated, "A truncated input was not recorded.");
    Equal(4000, capped.Budget.InputCharacters, "Summary input character count did not reflect truncation.");
    Equal(768, capped.Budget.MaxCompletionTokens, "Configured completion ceiling was not applied.");

    return Task.CompletedTask;
}

static async Task TestSummaryGeneratorPersistsBudgetMetadata()
{
    var store = new InMemoryCodeMeshStore();
    var provider = new CountingSummaryProvider();
    var text = string.Join(
        Environment.NewLine,
        Enumerable.Range(1, 50).Select(index => $"Step({index});"));
    var node = SummaryNode(
        CodeNodeKind.Method,
        "Execute",
        text,
        startLine: 10,
        endLine: 59);
    var repository = new RepositoryRef("repo:summary-budget", "/summary-budget");
    var generator = new CodeSummaryGenerator(provider, store);

    var result = await generator.GenerateAsync(
        repository,
        "run:summary-budget",
        [node],
        new Dictionary<string, CodeContent>
        {
            [node.ContentHash] = SummaryContent(text)
        });

    Equal(1, result.WrittenCount, "Summary budget metadata test did not generate a summary.");
    var metadata = result.Summaries[0].Metadata;
    Equal(SummaryBudgetPolicy.PolicyVersion, metadata["summaryBudgetPolicyVersion"], "Summary budget policy version was not persisted.");
    Equal("complex", metadata["summaryComplexityTier"], "Summary complexity tier was not persisted.");
    Equal("320", metadata["summaryVisibleTokenBudget"], "Visible summary token budget was not persisted.");
    Equal("768", metadata["summaryReasoningTokenReserve"], "Reasoning token reserve was not persisted.");
    Equal("1536", metadata["summaryMaxCompletionTokens"], "Completion ceiling was not persisted.");
    Equal("false", metadata["summaryInputTruncated"], "Summary truncation state was not persisted.");
    Equal("100", metadata["summaryInputTokens"], "Summary input token usage was not persisted.");
    Equal("25", metadata["summaryCachedInputTokens"], "Summary cached input token usage was not persisted.");
    Equal("5", metadata["summaryCacheWriteInputTokens"], "Summary cache-write input token usage was not persisted.");
    Equal("40", metadata["summaryOutputTokens"], "Summary output token usage was not persisted.");
    Equal("10", metadata["summaryReasoningTokens"], "Summary reasoning token usage was not persisted.");
    Equal("140", metadata["summaryTotalTokens"], "Summary total token usage was not persisted.");
    Equal("configured", metadata["testProviderSetting"], "Summary provider metadata was not persisted.");
    Equal(1536, provider.LastRequest?.Budget?.MaxCompletionTokens ?? 0, "Summary provider did not receive the selected completion ceiling.");
}

static async Task TestSummaryGeneratorRegeneratesWhenConfigurationChanges()
{
    var store = new InMemoryCodeMeshStore();
    const string text = "public int Add(int left, int right) => left + right;";
    var node = SummaryNode(
        CodeNodeKind.Method,
        "Add",
        text,
        startLine: 1,
        endLine: 1);
    var repository = new RepositoryRef("repo:summary-configuration", "/summary-configuration");
    var content = new Dictionary<string, CodeContent>
    {
        [node.ContentHash] = SummaryContent(text)
    };

    var firstProvider = new CountingSummaryProvider("reasoning-effort:none");
    var first = await new CodeSummaryGenerator(firstProvider, store)
        .GenerateAsync(repository, "run:summary-configuration-1", [node], content);
    Equal(1, first.WrittenCount, "Initial summary configuration did not generate a summary.");
    var firstSummaryId = first.Summaries[0].Id;

    var secondProvider = new CountingSummaryProvider("reasoning-effort:low");
    var second = await new CodeSummaryGenerator(secondProvider, store)
        .GenerateAsync(repository, "run:summary-configuration-2", [node], content);
    Equal(1, second.WrittenCount, "Changed provider configuration did not regenerate the summary.");
    Equal(0, second.SkippedCount, "Changed provider configuration incorrectly skipped the summary.");
    Equal(false, string.Equals(firstSummaryId, second.Summaries[0].Id, StringComparison.Ordinal), "Provider configuration did not affect summary identity.");
    var states = await store.GetSummaryStatesAsync(repository.Id);
    Equal(1, states.Count, "Changed provider configuration retained an obsolete summary variant.");

    var third = await new CodeSummaryGenerator(
            secondProvider,
            store,
            new CodeSummaryGenerationOptions(MaxCompletionTokens: 2048))
        .GenerateAsync(repository, "run:summary-configuration-3", [node], content);
    Equal(1, third.WrittenCount, "Changed budget configuration did not regenerate the summary.");
    Equal(false, string.Equals(second.Summaries[0].Id, third.Summaries[0].Id, StringComparison.Ordinal), "Budget configuration did not affect summary identity.");
    states = await store.GetSummaryStatesAsync(repository.Id);
    Equal(1, states.Count, "Changed budget configuration retained an obsolete summary variant.");

    var fourth = await new CodeSummaryGenerator(
            secondProvider,
            store,
            new CodeSummaryGenerationOptions(MaxCompletionTokens: 2048))
        .GenerateAsync(repository, "run:summary-configuration-4", [node], content);
    Equal(0, fourth.WrittenCount, "Unchanged generation configuration rewrote the summary.");
    Equal(1, fourth.SkippedCount, "Unchanged generation configuration did not skip the summary.");
}

static async Task TestSummaryQualificationRunnerAndCompiler()
{
    const string canary = "summary-qualification-secret-canary";
    const string source = "private const string ApiKey = \"summary-qualification-secret-canary\";";
    var qualificationItem = new SummaryQualificationCorpusItem(
        "secret-field",
        "repo:fixture",
        "0123456789abcdef",
        "node:secret-field",
        CodeMeshHash.Sha256Hex(source),
        "csharp",
        CodeNodeKind.Field,
        "ApiKey",
        "Fixture",
        "SecretFixture.cs",
        1,
        1,
        source,
        "small",
        "high",
        ["security-sensitive", "small"],
        ["The field stores an API key value."],
        [],
        ["The value is safe to publish."],
        ["field"],
        ["secret"],
        "qualification",
        "Stores an API key value.",
        [],
        [],
        [],
        [],
        "Stores an API key value.",
        [canary]);
    var calibrationItem = qualificationItem with
    {
        Id = "calibration-secret-field",
        NodeId = "node:calibration-secret-field",
        Partition = "calibration"
    };
    var suite = new SummaryQualificationSuite(
        SummaryQualificationConstants.SchemaVersion,
        SummaryQualificationConstants.SuiteKind,
        "synthetic-summary-suite",
        "1.0.0",
        [calibrationItem, qualificationItem],
        new SummaryQualificationGates(
            MaximumP95LatencyMs: 1000,
            MinimumNodesPerMinute: 1,
            MaximumTotalTokens: 1000,
            MaximumTokensPerSuccessfulNode: 200,
            MaximumTotalDurationMs: 5000,
            MaximumRetryTokenOverheadRatio: 0,
            MaximumPeakHostMemoryMb: 512));
    var profile = new SummaryQualificationProfile(
        SummaryQualificationConstants.SchemaVersion,
        SummaryQualificationConstants.ProfileKind,
        "deterministic-local",
        "local-offline",
        "local",
        "test",
        "summary-counting",
        "fixture-v1",
        "none",
        "float32",
        CodeMeshHash.Sha256Hex("fixture-template"),
        8192,
        4000,
        768,
        1536,
        3,
        new Dictionary<string, string>
        {
            ["temperature"] = "0",
            ["topP"] = "1",
            ["topK"] = "not-applicable",
            ["seed"] = "1",
            ["stopSequences"] = "none",
            ["requestedReasoningEffort"] = "none",
            ["effectiveReasoningEffort"] = "none",
            ["providerGenerationConfigurationFingerprint"] = "fixture-configuration-v1",
            ["retryPolicy"] = "none",
            ["timeout"] = "10s",
            ["concurrency"] = "1",
            ["batching"] = "1"
        },
        new Dictionary<string, string>
        {
            ["operatingSystem"] = "test-os",
            ["cpu"] = "test-cpu",
            ["memory"] = "1 GiB",
            ["accelerator"] = "none",
            ["acceleratorMemory"] = "none",
            ["servingRuntime"] = "test"
        });
    var sourceIdentity = new SummaryQualificationSourceIdentity(
        "fedcba9876543210",
        false,
        "main",
        "https://example.invalid/codemesh",
        "test-os",
        "test-runtime");

    var result = await new SummaryQualificationRunner(new CountingSummaryProvider("fixture-configuration-v1"))
        .RunAsync(suite, profile, sourceIdentity);

    Equal(4, result.PrivateArchive.Samples.Count, "Qualification warm-up and repetitions were not executed.");
    Equal(4, result.PrivateArchive.Samples.Count(sample => sample.Completed), "Deterministic qualification samples did not complete.");
    Equal(false, result.ReviewPacket.Items.Any(review => review.Source.Contains(canary, StringComparison.Ordinal)), "The blinded review packet retained a secret canary.");

    SummaryQualificationReview Review(string reviewerId)
    {
        return new SummaryQualificationReview(
            SummaryQualificationConstants.SchemaVersion,
            SummaryQualificationConstants.ReviewKind,
            result.PrivateArchive.RunId,
            reviewerId,
            true,
            CodeMeshHash.Sha256Hex("resolved-review-calibration-v1"),
            result.PrivateArchive.Samples
                .Where(sample => string.Equals(sample.Phase, "measured", StringComparison.Ordinal))
                .Select(sample => new SummaryQualificationSampleReview(
                sample.SampleId,
                sample.ItemId,
                1,
                1,
                1,
                1,
                false,
                false,
                true,
                0,
                0,
                1,
                true,
                true,
                1,
                0,
                0)).ToArray());
    }

    var baselineReportHash = CodeMeshHash.Sha256Hex("baseline-report");
    var candidateReportHash = CodeMeshHash.Sha256Hex("candidate-report");
    var retrievalAssessment = new SummaryQualificationRetrievalAssessment(
        SummaryQualificationConstants.SchemaVersion,
        SummaryQualificationConstants.RetrievalAssessmentKind,
        result.PrivateArchive.RunId,
        baselineReportHash,
        candidateReportHash,
        1,
        0,
        1,
        0,
        0,
        0.9,
        0.9,
        1,
        1,
        0,
        true);
    var retrieval = new SummaryQualificationRetrievalEvidence(
        SummaryQualificationConstants.SchemaVersion,
        SummaryQualificationConstants.RetrievalEvidenceKind,
        result.PrivateArchive.RunId,
        result.PrivateArchive.SuiteHash,
        result.PrivateArchive.PromptHash,
        result.PrivateArchive.CorpusRepositoryIdentityHash,
        CodeMeshHash.Sha256Hex("ranking-v1"),
        "synthetic-live",
        "repo:fixture",
        "0123456789abcdef",
        baselineReportHash,
        candidateReportHash,
        new SummaryRetrievalMetrics(0.9, 0.9, 0.9, 0.9, 1, 0, true, true),
        new SummaryRetrievalMetrics(0.9, 0.9, 0.9, 0.9, 1, 0, true, true),
        retrievalAssessment,
        []);
    var deployment = new SummaryQualificationDeploymentEvidence(
        SummaryQualificationConstants.SchemaVersion,
        SummaryQualificationConstants.DeploymentEvidenceKind,
        result.PrivateArchive.RunId,
        result.PrivateArchive.ProfileHash,
        "deterministic fixture measurement",
        256,
        null,
        null,
        null,
        true);
    var reviews = new[] { Review("reviewer-a"), Review("reviewer-b") };
    var report = SummaryQualificationCompiler.Compile(suite, result.PrivateArchive, reviews, retrieval, deployment);
    Equal("qualified", report.Outcome, "A complete passing qualification run was not qualified.");
    Equal(1d, report.Metrics.RequiredFactRecallByStratum["security-sensitive"], "Stratum recall was not calculated from item identities.");
    Equal(560L, report.Metrics.TotalTokens, "Provider usage was not aggregated across warm-up and measured attempts.");

    Equal(1d, report.Metrics.IdenticalInputStability, "Repeated identical inputs were not compared for stability.");
    Equal(256d, report.Metrics.PeakHostMemoryMb, "Deployment evidence was not included in the report.");

    var missingRetrieval = SummaryQualificationCompiler.Compile(suite, result.PrivateArchive, reviews, null, deployment);
    Equal("invalid-run", missingRetrieval.Outcome, "Missing retrieval evidence did not invalidate qualification.");
    Throws<InvalidOperationException>(
        () => SummaryQualificationCompiler.Compare(report, report with { SuiteHash = "different-suite" }),
        "Incompatible qualification reports were compared.");
}

static async Task TestForcedEmbeddingIngestionRebuildsUnchangedEmbeddings()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-force-embeddings-test-{Guid.NewGuid():N}");
    Directory.CreateDirectory(root);

    try
    {
        var store = new InMemoryCodeMeshStore();
        var parser = new RefreshParserClient("Alpha");
        var embeddingProvider = new CountingEmbeddingProvider();
        var orchestrator = new IngestionOrchestrator(
            parser,
            store,
            store,
            store,
            embeddingProvider);

        await orchestrator.IngestAsync(new IngestionRequest(
            root,
            DryRun: false,
            SkipEmbeddings: false));
        var second = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            DryRun: false,
            SkipEmbeddings: false));
        Equal(0, second.Stats?.WrittenEmbeddingCount ?? -1, "Unchanged ingestion should not rewrite embeddings before force mode.");
        Equal(1, second.Stats?.SkippedEmbeddingCount ?? -1, "Unchanged ingestion should skip the existing embedding before force mode.");
        Equal(1, embeddingProvider.EmbeddedNodeCount, "Unchanged ingestion called the embedding provider before force mode.");

        var forced = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            DryRun: false,
            SkipEmbeddings: false,
            ForceEmbeddings: true));

        Equal(1, forced.Stats?.WrittenEmbeddingCount ?? -1, "Forced ingestion did not rewrite the unchanged embedding.");
        Equal(0, forced.Stats?.SkippedEmbeddingCount ?? -1, "Forced ingestion incorrectly skipped an unchanged embedding.");
        Equal(2, embeddingProvider.EmbeddedNodeCount, "Forced ingestion did not call the embedding provider again.");
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static async Task TestEmbeddingVerifierReportsMissingAndStaleVectors()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-verify-embeddings-test-{Guid.NewGuid():N}");
    Directory.CreateDirectory(root);

    try
    {
        var store = new InMemoryCodeMeshStore();
        var parser = new RefreshParserClient("Alpha");
        var embeddingProvider = new CountingEmbeddingProvider();
        var orchestrator = new IngestionOrchestrator(
            parser,
            store,
            store,
            store,
            embeddingProvider);
        var result = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            DryRun: false,
            SkipEmbeddings: false));
        var verifier = new EmbeddingVerifier(store, store);

        var complete = await verifier.VerifyAsync(new EmbeddingVerificationRequest(
            result.Repository.Id,
            embeddingProvider.Provider,
            embeddingProvider.Model));
        Equal(true, complete.IsComplete, "Verifier did not report complete embeddings after ingestion.");
        Equal(1, complete.ExpectedCount, "Verifier expected node count changed.");
        Equal(1, complete.CurrentEmbeddingCount, "Verifier current embedding count changed.");

        await store.RemoveEmbeddingsExceptAsync(result.Repository.Id, new HashSet<string>(StringComparer.Ordinal));
        await store.UpsertEmbeddingsAsync([
            new EmbeddingRecord(
                "embedding:stale",
                "csharp:type:Sample.Stale",
                "stale-content",
                embeddingProvider.Provider,
                embeddingProvider.Model,
                2,
                [1.0f, 0.0f],
                new Dictionary<string, string>
                {
                    ["repositoryId"] = result.Repository.Id,
                    ["preview"] = "stale"
                })
        ]);

        var incomplete = await verifier.VerifyAsync(new EmbeddingVerificationRequest(
            result.Repository.Id,
            embeddingProvider.Provider,
            embeddingProvider.Model));
        Equal(false, incomplete.IsComplete, "Verifier did not report incomplete embeddings.");
        Equal(1, incomplete.MissingCount, "Verifier did not report the missing current embedding.");
        Equal(1, incomplete.StaleCount, "Verifier did not report the stale embedding.");

        var missingRepository = await verifier.VerifyAsync(new EmbeddingVerificationRequest(
            "missing-repository",
            embeddingProvider.Provider,
            embeddingProvider.Model));
        Equal(false, missingRepository.IsComplete, "Verifier incorrectly reported a missing repository as complete.");
        Equal("empty_graph", missingRepository.Issues[0].Kind, "Verifier did not report an empty graph inventory.");
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static async Task TestRepositoryCleanupRemovesIndexedData()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-cleanup-test-{Guid.NewGuid():N}");
    Directory.CreateDirectory(root);

    try
    {
        var store = new InMemoryCodeMeshStore();
        var parser = new RefreshParserClient("Alpha");
        var embeddingProvider = new CountingEmbeddingProvider();
        var summaryProvider = new CountingSummaryProvider();
        var orchestrator = new IngestionOrchestrator(
            parser,
            store,
            store,
            store,
            embeddingProvider,
            store,
            store,
            summaryProvider);
        var result = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            DryRun: false,
            SkipEmbeddings: false,
            IncludeSummaries: true));

        var repositoryId = result.Repository.Id;
        var snapshotId = result.Repository.SnapshotId
            ?? throw new InvalidOperationException("Cleanup setup did not publish a snapshot id.");
        NotNull(await store.GetNodeAsync(RefreshParserClient.NodeIdFor("Alpha")), "Cleanup setup did not write a graph node.");
        NotNull(await store.GetContentAsync(RefreshParserClient.ContentHashFor("Alpha")), "Cleanup setup did not write content.");
        Equal(1, (await store.GetEmbeddingStatesAsync(snapshotId)).Count, "Cleanup setup did not write an embedding.");
        Equal(1, (await store.GetSummaryStatesAsync(snapshotId)).Count, "Cleanup setup did not write a summary.");
        NotNull(await store.GetRepositoryAsync(repositoryId), "Cleanup setup did not write repository metadata.");
        Equal(1, (await store.ListRunsAsync(repositoryId)).Count, "Cleanup setup did not write an ingestion run.");

        var cleanup = new RepositoryCleanupService(
            store,
            store,
            store,
            store,
            store);
        var cleanupResult = await cleanup.DeleteRepositoryAsync(repositoryId);

        Equal(repositoryId, cleanupResult.RepositoryId, "Cleanup result repository id changed.");
        Equal(true, cleanupResult.RegistryEntryExisted, "Cleanup did not find the registry entry.");
        Equal(true, cleanupResult.GraphCleaned, "Cleanup did not report graph cleanup.");
        Equal(true, cleanupResult.ContentCleaned, "Cleanup did not report content cleanup.");
        Equal(true, cleanupResult.EmbeddingsCleaned, "Cleanup did not report embedding cleanup.");
        Equal(true, cleanupResult.SummariesCleaned, "Cleanup did not report summary cleanup.");
        IsNull(await store.GetNodeAsync(RefreshParserClient.NodeIdFor("Alpha")), "Cleanup did not remove graph node.");
        IsNull(await store.GetContentAsync(RefreshParserClient.ContentHashFor("Alpha")), "Cleanup did not remove content.");
        Equal(0, (await store.GetContentStatesAsync(snapshotId)).Count, "Cleanup left content state behind.");
        Equal(0, (await store.GetEmbeddingStatesAsync(snapshotId)).Count, "Cleanup left embeddings behind.");
        Equal(0, (await store.GetSummaryStatesAsync(snapshotId)).Count, "Cleanup left summaries behind.");
        IsNull(await store.GetRepositoryAsync(repositoryId), "Cleanup did not remove repository metadata.");
        Equal(0, (await store.ListRunsAsync(repositoryId)).Count, "Cleanup did not remove ingestion runs.");

        var matches = await store.SearchAsync(
            [1.0f, 0.0f],
            10,
            new Dictionary<string, string> { ["repositoryId"] = snapshotId });
        Equal(0, matches.Count, "Cleanup left searchable embeddings behind.");
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static async Task TestRepositoryAliasesAreGeneratedAndResolved()
{
    Equal("youtube_downloader", RepositoryAlias.Normalize("YoutubeDownloader"), "Repository alias PascalCase normalization changed.");
    Equal("youtube_downloader", RepositoryAlias.Normalize("youtube-downloader"), "Repository alias separator normalization changed.");

    var root = Path.Combine(Path.GetTempPath(), "YoutubeDownloader");
    Directory.CreateDirectory(root);

    try
    {
        var store = new InMemoryCodeMeshStore();
        var orchestrator = new IngestionOrchestrator(
            new FakeParserClient(),
            store,
            store,
            store,
            new NoEmbeddingProvider(),
            store);

        var result = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            DryRun: false,
            SkipEmbeddings: true));

        var loadedById = await store.GetRepositoryAsync(result.Repository.Id);
        NotNull(loadedById, "Registry did not load repository by id.");
        Equal("youtube_downloader", loadedById!.Alias ?? string.Empty, "Registry alias changed.");
        Equal("youtube_downloader", loadedById.Metadata["alias"], "Registry alias metadata changed.");

        var loadedByAlias = await store.GetRepositoryAsync("youtube_downloader");
        NotNull(loadedByAlias, "Registry did not load repository by alias.");
        Equal(result.Repository.Id, loadedByAlias!.RepositoryId, "Registry alias resolved to the wrong repository id.");
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static async Task TestIngestionWritesRepositoryRegistryRecords()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-registry-test-{Guid.NewGuid():N}");
    Directory.CreateDirectory(root);

    try
    {
        var store = new InMemoryCodeMeshStore();
        var orchestrator = new IngestionOrchestrator(
            new FakeParserClient(),
            store,
            store,
            store,
            new NoEmbeddingProvider(),
            store);

        var result = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            DryRun: false,
            SkipEmbeddings: true));

        var repositories = await store.ListRepositoriesAsync();
        Equal(1, repositories.Count, "Registry did not record the ingested repository.");
        Equal(result.Repository.Id, repositories[0].RepositoryId, "Registry repository id changed.");
        Equal(result.Run.RunId, repositories[0].LastRunId ?? string.Empty, "Registry last run id changed.");
        Equal(IngestionStage.Completed, repositories[0].LastStage ?? IngestionStage.Failed, "Registry last stage changed.");
        Equal(1, repositories[0].NodeCount, "Registry node count changed.");
        Equal(1, repositories[0].ContentCount, "Registry content count changed.");

        var loadedRepository = await store.GetRepositoryAsync(result.Repository.Id);
        NotNull(loadedRepository, "Registry did not load the repository by id.");
        Equal(root, loadedRepository!.RootPath, "Registry repository root changed.");

        var runs = await store.ListRunsAsync(result.Repository.Id);
        Equal(1, runs.Count, "Registry did not record the ingestion run.");
        Equal(result.Run.RunId, runs[0].RunId, "Registry run id changed.");
        Equal("fake-parser", runs[0].ParserName, "Registry parser name changed.");
        Equal("none", runs[0].EmbeddingProvider, "Registry embedding provider changed.");
        Equal(1, runs[0].Stats?.ParsedNodeCount ?? 0, "Registry stats changed.");
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static async Task TestIngestionStampsGitRepositoryMetadata()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-git-metadata-test-{Guid.NewGuid():N}");
    Directory.CreateDirectory(root);

    try
    {
        RunGit(root, "init", "--initial-branch", "evaluation");
        RunGit(root, "config", "user.email", "codemesh@example.invalid");
        RunGit(root, "config", "user.name", "CodeMesh Tests");
        File.WriteAllText(Path.Combine(root, "sample.txt"), "indexed content");
        RunGit(root, "add", "sample.txt");
        RunGit(root, "commit", "-m", "test commit");
        RunGit(root, "remote", "add", "origin", "https://example.invalid/codemesh.git");
        var expectedCommit = RunGit(root, "rev-parse", "HEAD");

        var store = new InMemoryCodeMeshStore();
        var orchestrator = new IngestionOrchestrator(
            new FakeParserClient(),
            store,
            store,
            store,
            new NoEmbeddingProvider(),
            store);

        var result = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            DryRun: false,
            SkipEmbeddings: true));

        Equal(expectedCommit, result.Repository.Commit ?? string.Empty, "Ingestion did not stamp the Git commit.");
        Equal("evaluation", result.Repository.Branch ?? string.Empty, "Ingestion did not stamp the Git branch.");
        Equal("https://example.invalid/codemesh.git", result.Repository.RemoteUrl ?? string.Empty, "Ingestion did not stamp the Git remote.");

        var repository = await store.GetRepositoryAsync(result.Repository.Id);
        NotNull(repository, "Registry did not retain Git repository metadata.");
        Equal(expectedCommit, repository!.Commit ?? string.Empty, "Registry did not retain the Git commit.");
        Equal("evaluation", repository.Branch ?? string.Empty, "Registry did not retain the Git branch.");
        Equal("https://example.invalid/codemesh.git", repository.RemoteUrl ?? string.Empty, "Registry did not retain the Git remote.");
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static async Task TestSnapshotSlotsRetainCleanHeadsAndBoundDirtyHistory()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-snapshot-slots-{Guid.NewGuid():N}");
    Directory.CreateDirectory(root);

    try
    {
        RunGit(root, "init", "--initial-branch", "main");
        RunGit(root, "config", "user.email", "codemesh@example.invalid");
        RunGit(root, "config", "user.name", "CodeMesh Tests");
        File.WriteAllText(Path.Combine(root, "source.txt"), "alpha");
        RunGit(root, "add", "source.txt");
        RunGit(root, "commit", "-m", "alpha");

        var store = new InMemoryCodeMeshStore();
        var parser = new RefreshParserClient("Alpha");
        var orchestrator = new IngestionOrchestrator(
            parser,
            store,
            store,
            store,
            new NoEmbeddingProvider(),
            store);

        var clean = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            SkipEmbeddings: true,
            SnapshotRetentionGraceSeconds: 0));
        var projectId = clean.Repository.ProjectId ?? clean.Repository.Id;
        var checkoutId = clean.Repository.CheckoutId ?? throw new InvalidOperationException("Checkout id was not published.");
        var cleanSnapshotId = clean.Repository.SnapshotId ?? throw new InvalidOperationException("Snapshot id was not published.");
        Equal(string.Empty, RunGit(root, "status", "--porcelain"), "Private identity markers dirtied the checkout.");

        var identical = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            SkipEmbeddings: true,
            SnapshotRetentionGraceSeconds: 0));
        Equal(cleanSnapshotId, identical.Repository.SnapshotId ?? string.Empty, "Identical effective inputs created another snapshot.");
        Equal(1, (await store.ListSnapshotsAsync(projectId)).Count, "Identical ingestion retained duplicate snapshot state.");

        File.WriteAllText(Path.Combine(root, "source.txt"), "beta");
        parser.TypeName = "Beta";
        var dirtyBeta = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            SkipEmbeddings: true,
            SnapshotRetentionGraceSeconds: 0));
        var betaSnapshotId = dirtyBeta.Repository.SnapshotId ?? throw new InvalidOperationException("Dirty snapshot id was not published.");
        var branchSlot = await store.ResolveSlotAsync(projectId, SnapshotSlotKind.BranchHead, "refs/heads/main");
        var checkoutSlot = await store.ResolveSlotAsync(projectId, SnapshotSlotKind.CheckoutCurrent, checkoutId);
        Equal(cleanSnapshotId, branchSlot?.SnapshotId ?? string.Empty, "Dirty ingestion moved the branch-head slot.");
        Equal(betaSnapshotId, checkoutSlot?.SnapshotId ?? string.Empty, "Dirty ingestion did not move checkout-current.");

        File.WriteAllText(Path.Combine(root, "source.txt"), "gamma");
        parser.TypeName = "Gamma";
        var dirtyGamma = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            SkipEmbeddings: true,
            SnapshotRetentionGraceSeconds: 0));
        var gammaSnapshotId = dirtyGamma.Repository.SnapshotId ?? throw new InvalidOperationException("Replacement dirty snapshot id was not published.");
        var collectible = await store.ListCollectibleSnapshotsAsync(DateTimeOffset.UtcNow.AddSeconds(1));
        Equal(true, collectible.Any(snapshot => snapshot.SnapshotId == betaSnapshotId), "Superseded dirty snapshot was not collectible.");

        var garbageCollector = new SnapshotGarbageCollector(store, store, store, store, store);
        var collection = await garbageCollector.CollectAsync(DateTimeOffset.UtcNow.AddSeconds(1));
        Equal(true, collection.DeletedSnapshotIds.Contains(betaSnapshotId), "Garbage collection did not remove the superseded dirty snapshot.");
        Equal(2, (await store.ListSnapshotsAsync(projectId)).Count, "Bounded retention kept an intermediate dirty snapshot.");

        RunGit(root, "add", "source.txt");
        RunGit(root, "commit", "-m", "gamma");
        var cleanGamma = await orchestrator.IngestAsync(new IngestionRequest(
            root,
            SkipEmbeddings: true,
            SnapshotRetentionGraceSeconds: 0));
        Equal(gammaSnapshotId, cleanGamma.Repository.SnapshotId ?? string.Empty, "Clean checkout did not reuse the matching dirty source snapshot.");
        branchSlot = await store.ResolveSlotAsync(projectId, SnapshotSlotKind.BranchHead, "refs/heads/main");
        Equal(gammaSnapshotId, branchSlot?.SnapshotId ?? string.Empty, "Clean ingestion did not move the branch-head slot.");
    }
    finally
    {
        if (Directory.Exists(root))
        {
            Directory.Delete(root, recursive: true);
        }
    }
}

static async Task TestCheckoutIdentitySurvivesMovesAndRejectsLiveCopies()
{
    var parent = Path.Combine(Path.GetTempPath(), $"codemesh-checkout-identity-{Guid.NewGuid():N}");
    var original = Path.Combine(parent, "original");
    var moved = Path.Combine(parent, "moved");
    var copied = Path.Combine(parent, "copied");
    Directory.CreateDirectory(original);

    try
    {
        var store = new InMemoryCodeMeshStore();
        var orchestrator = new IngestionOrchestrator(
            new FakeParserClient(),
            store,
            store,
            store,
            new NoEmbeddingProvider(),
            store);
        var first = await orchestrator.IngestAsync(new IngestionRequest(original, SkipEmbeddings: true));
        var firstCheckoutId = first.Repository.CheckoutId ?? throw new InvalidOperationException("Initial checkout id was absent.");
        var projectId = first.Repository.ProjectId ?? first.Repository.Id;
        File.WriteAllText(
            Path.Combine(original, ".codemesh", "project.json"),
            JsonSerializer.Serialize(new
            {
                format_version = 1,
                project_id = projectId,
                created_at_utc = DateTimeOffset.UtcNow
            }));

        Directory.Move(original, moved);
        var afterMove = await orchestrator.IngestAsync(new IngestionRequest(moved, SkipEmbeddings: true));
        Equal(firstCheckoutId, afterMove.Repository.CheckoutId ?? string.Empty, "Moving a folder changed checkout identity.");
        Equal(projectId, afterMove.Repository.ProjectId ?? string.Empty, "Moving a folder changed project identity.");
        Equal("original", (await store.GetRepositoryAsync(projectId))?.Alias ?? string.Empty, "Moving a folder changed the project alias.");

        CopyDirectory(moved, copied);
        var afterCopy = await orchestrator.IngestAsync(new IngestionRequest(copied, SkipEmbeddings: true));
        if (string.Equals(firstCheckoutId, afterCopy.Repository.CheckoutId, StringComparison.Ordinal))
        {
            throw new InvalidOperationException("A simultaneously live copied marker reused checkout identity.");
        }
        Equal(projectId, afterCopy.Repository.ProjectId ?? string.Empty, "Copied checkout did not retain explicit project identity.");
        Equal("original", (await store.GetRepositoryAsync(projectId))?.Alias ?? string.Empty, "Copied checkout changed the project alias.");
    }
    finally
    {
        if (Directory.Exists(parent))
        {
            Directory.Delete(parent, recursive: true);
        }
    }
}

static async Task TestLinkedWorktreesShareProjectsButNotCheckouts()
{
    var parent = Path.Combine(Path.GetTempPath(), $"codemesh-worktree-identity-{Guid.NewGuid():N}");
    var mainRoot = Path.Combine(parent, "main");
    var worktreeRoot = Path.Combine(parent, "feature");
    Directory.CreateDirectory(mainRoot);

    try
    {
        RunGit(mainRoot, "init", "--initial-branch", "main");
        RunGit(mainRoot, "config", "user.email", "codemesh@example.invalid");
        RunGit(mainRoot, "config", "user.name", "CodeMesh Tests");
        File.WriteAllText(Path.Combine(mainRoot, "source.txt"), "same source");
        File.WriteAllText(Path.Combine(mainRoot, "Source.sln"), string.Empty);
        RunGit(mainRoot, "add", "source.txt", "Source.sln");
        RunGit(mainRoot, "commit", "-m", "initial");

        var store = new InMemoryCodeMeshStore();
        var orchestrator = new IngestionOrchestrator(new FakeParserClient(), store, store, store, new NoEmbeddingProvider(), store);
        var main = await orchestrator.IngestAsync(new IngestionRequest(
            mainRoot,
            SolutionPath: Path.Combine(mainRoot, "Source.sln"),
            SkipEmbeddings: true));
        RunGit(mainRoot, "worktree", "add", "-b", "feature", worktreeRoot);
        var feature = await orchestrator.IngestAsync(new IngestionRequest(
            worktreeRoot,
            SolutionPath: Path.Combine(worktreeRoot, "Source.sln"),
            SkipEmbeddings: true));

        Equal(main.Repository.ProjectId ?? string.Empty, feature.Repository.ProjectId ?? string.Empty, "Linked worktrees did not share project identity.");
        if (string.Equals(main.Repository.CheckoutId, feature.Repository.CheckoutId, StringComparison.Ordinal))
        {
            throw new InvalidOperationException("Linked worktrees reused checkout identity.");
        }
        Equal(main.Repository.SnapshotId ?? string.Empty, feature.Repository.SnapshotId ?? string.Empty, "Identical linked worktree source did not reuse snapshot identity.");
        Equal("main", (await store.GetRepositoryAsync(main.Repository.Id))?.Alias ?? string.Empty, "Linked worktree ingestion changed the project alias.");
    }
    finally
    {
        if (Directory.Exists(parent))
        {
            Directory.Delete(parent, recursive: true);
        }
    }
}

static async Task TestExplicitPinsProtectSnapshotsUntilReleased()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-snapshot-pin-{Guid.NewGuid():N}");
    Directory.CreateDirectory(root);
    try
    {
        var store = new InMemoryCodeMeshStore();
        var parser = new RefreshParserClient("Alpha");
        var orchestrator = new IngestionOrchestrator(parser, store, store, store, new NoEmbeddingProvider(), store);
        var first = await orchestrator.IngestAsync(new IngestionRequest(root, SkipEmbeddings: true, SnapshotRetentionGraceSeconds: 0));
        var projectId = first.Repository.ProjectId ?? first.Repository.Id;
        var firstSnapshotId = first.Repository.SnapshotId ?? throw new InvalidOperationException("First snapshot id was absent.");
        var pinned = await store.UpsertRetainedSlotAsync(
            projectId,
            SnapshotSlotKind.ExplicitPin,
            "evaluation-1",
            firstSnapshotId,
            expectedVersion: null);
        Equal(true, pinned.Changed, "Explicit pin was not created.");
        var stalePin = await store.UpsertRetainedSlotAsync(
            projectId,
            SnapshotSlotKind.ExplicitPin,
            "evaluation-1",
            firstSnapshotId,
            expectedVersion: 0);
        Equal(false, stalePin.Changed, "A stale slot writer replaced an explicit pin.");

        parser.TypeName = "Beta";
        var second = await orchestrator.IngestAsync(new IngestionRequest(root, SkipEmbeddings: true, SnapshotRetentionGraceSeconds: 0));
        var secondSnapshotId = second.Repository.SnapshotId ?? throw new InvalidOperationException("Second snapshot id was absent.");
        if (string.Equals(firstSnapshotId, secondSnapshotId, StringComparison.Ordinal))
        {
            throw new InvalidOperationException("Changed source unexpectedly reused its prior snapshot.");
        }
        Equal(false, (await store.ListCollectibleSnapshotsAsync(DateTimeOffset.UtcNow.AddSeconds(1))).Any(snapshot => snapshot.SnapshotId == firstSnapshotId), "Pinned snapshot became collectible.");

        var released = await store.DeleteSlotAsync(
            projectId,
            SnapshotSlotKind.ExplicitPin,
            "evaluation-1",
            pinned.Slot?.Version,
            TimeSpan.Zero);
        Equal(true, released.Changed, "Explicit pin was not released.");
        Equal(true, released.NewlyCollectibleSnapshotIds.Contains(firstSnapshotId), "Unpinned unreferenced snapshot did not become collectible.");
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static async Task TestFailedSnapshotGenerationPreservesActiveSlots()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-snapshot-failure-{Guid.NewGuid():N}");
    Directory.CreateDirectory(root);
    try
    {
        RunGit(root, "init", "--initial-branch", "main");
        RunGit(root, "config", "user.email", "codemesh@example.invalid");
        RunGit(root, "config", "user.name", "CodeMesh Tests");
        File.WriteAllText(Path.Combine(root, "source.txt"), "alpha");
        RunGit(root, "add", "source.txt");
        RunGit(root, "commit", "-m", "alpha");

        var store = new InMemoryCodeMeshStore();
        var parser = new RefreshParserClient("Alpha");
        var successful = new IngestionOrchestrator(parser, store, store, store, new NoEmbeddingProvider(), store);
        var first = await successful.IngestAsync(new IngestionRequest(root, SkipEmbeddings: true));
        var projectId = first.Repository.ProjectId ?? first.Repository.Id;
        var firstSnapshotId = first.Repository.SnapshotId ?? throw new InvalidOperationException("Initial snapshot id was absent.");

        File.WriteAllText(Path.Combine(root, "source.txt"), "beta");
        RunGit(root, "add", "source.txt");
        RunGit(root, "commit", "-m", "beta");
        parser.TypeName = "Beta";
        var failing = new IngestionOrchestrator(new RefreshParserClient("Beta"), new FailingGraphStore(), store, store, new NoEmbeddingProvider(), store);
        await ThrowsAsync<InvalidOperationException>(
            () => failing.IngestAsync(new IngestionRequest(root, SkipEmbeddings: true)),
            "A graph-store publication failure did not fail ingestion.");

        var branchSlot = await store.ResolveSlotAsync(projectId, SnapshotSlotKind.BranchHead, "refs/heads/main");
        Equal(firstSnapshotId, branchSlot?.SnapshotId ?? string.Empty, "Failed generation replaced the active branch slot.");
        var collectible = await store.ListCollectibleSnapshotsAsync(DateTimeOffset.UtcNow.AddSeconds(1));
        Equal(true, collectible.Any(snapshot => snapshot.State == SnapshotState.Failed), "Failed generation was not retained for retryable cleanup.");
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static async Task TestStatusUsesConfiguredOllamaEndpoint()
{
    var previousUrl = Environment.GetEnvironmentVariable("CODEMESH_OLLAMA_URL");
    var previousProvider = Environment.GetEnvironmentVariable("CODEMESH_MODEL_PROVIDER");
    var previousModel = Environment.GetEnvironmentVariable("CODEMESH_EMBEDDING_MODEL");

    await using var server = new SlowHttpServer(TimeSpan.FromMilliseconds(1100));

    try
    {
        Environment.SetEnvironmentVariable("CODEMESH_OLLAMA_URL", server.BaseUrl);
        Environment.SetEnvironmentVariable("CODEMESH_MODEL_PROVIDER", "ollama");
        Environment.SetEnvironmentVariable("CODEMESH_EMBEDDING_MODEL", "test-embed");

        var report = await new CodeMeshStatusService()
            .GetStatusAsync(Directory.GetCurrentDirectory());
        var ollama = report.Components.Single(component => component.Name == "ollama");

        Equal(ComponentState.Healthy, ollama.State, "Status did not use the configured slow Ollama endpoint.");
        Equal($"{server.BaseUrl}/api/tags", ollama.Metadata["endpoint"], "Status did not probe the configured Ollama URL.");
        Equal("ollama", ollama.Metadata["provider"], "Status did not report the configured model provider.");
        Equal("test-embed", ollama.Metadata["model"], "Status did not report the configured embedding model.");
    }
    finally
    {
        Environment.SetEnvironmentVariable("CODEMESH_OLLAMA_URL", previousUrl);
        Environment.SetEnvironmentVariable("CODEMESH_MODEL_PROVIDER", previousProvider);
        Environment.SetEnvironmentVariable("CODEMESH_EMBEDDING_MODEL", previousModel);
    }
}

static async Task TestStatusRetriesTransientOllamaFailures()
{
    var previousUrl = Environment.GetEnvironmentVariable("CODEMESH_OLLAMA_URL");
    var previousProvider = Environment.GetEnvironmentVariable("CODEMESH_MODEL_PROVIDER");
    var previousModel = Environment.GetEnvironmentVariable("CODEMESH_EMBEDDING_MODEL");

    await using var server = new SlowHttpServer(TimeSpan.Zero, failuresBeforeSuccess: 1);

    try
    {
        Environment.SetEnvironmentVariable("CODEMESH_OLLAMA_URL", server.BaseUrl);
        Environment.SetEnvironmentVariable("CODEMESH_MODEL_PROVIDER", "ollama");
        Environment.SetEnvironmentVariable("CODEMESH_EMBEDDING_MODEL", "test-embed");

        var report = await new CodeMeshStatusService()
            .GetStatusAsync(Directory.GetCurrentDirectory());
        var ollama = report.Components.Single(component => component.Name == "ollama");

        Equal(ComponentState.Healthy, ollama.State, "Status did not retry a transient Ollama probe failure.");
        if (server.RequestCount < 2)
        {
            throw new InvalidOperationException("Status did not issue a retry after the transient Ollama failure.");
        }
    }
    finally
    {
        Environment.SetEnvironmentVariable("CODEMESH_OLLAMA_URL", previousUrl);
        Environment.SetEnvironmentVariable("CODEMESH_MODEL_PROVIDER", previousProvider);
        Environment.SetEnvironmentVariable("CODEMESH_EMBEDDING_MODEL", previousModel);
    }
}

static async Task TestStatusDegradesWhenConfiguredModelIsMissing()
{
    var previousUrl = Environment.GetEnvironmentVariable("CODEMESH_LM_STUDIO_URL");
    var previousProvider = Environment.GetEnvironmentVariable("CODEMESH_MODEL_PROVIDER");
    var previousModel = Environment.GetEnvironmentVariable("CODEMESH_EMBEDDING_MODEL");

    await using var server = new SlowHttpServer(
        TimeSpan.Zero,
        responseBody: """{"data":[{"id":"other-model"}]}""");

    try
    {
        Environment.SetEnvironmentVariable("CODEMESH_LM_STUDIO_URL", server.BaseUrl);
        Environment.SetEnvironmentVariable("CODEMESH_MODEL_PROVIDER", "lmstudio");
        Environment.SetEnvironmentVariable("CODEMESH_EMBEDDING_MODEL", "expected-model");

        var report = await new CodeMeshStatusService()
            .GetStatusAsync(Directory.GetCurrentDirectory());
        var lmStudio = report.Components.Single(component => component.Name == "lmstudio");

        Equal(ComponentState.Degraded, lmStudio.State, "Status did not degrade when the configured model was missing.");
        Equal($"{server.BaseUrl}/models", lmStudio.Metadata["endpoint"], "Status did not probe the configured LM Studio URL.");
        Equal("lmstudio", lmStudio.Metadata["provider"], "Status did not report the configured LM Studio provider.");
        Equal("expected-model", lmStudio.Metadata["model"], "Status did not report the configured LM Studio model.");
        Equal(
            "Configured embedding model is not listed by the model provider.",
            lmStudio.Metadata["detail"],
            "Status did not report the missing model detail.");
    }
    finally
    {
        Environment.SetEnvironmentVariable("CODEMESH_LM_STUDIO_URL", previousUrl);
        Environment.SetEnvironmentVariable("CODEMESH_MODEL_PROVIDER", previousProvider);
        Environment.SetEnvironmentVariable("CODEMESH_EMBEDDING_MODEL", previousModel);
    }
}

static async Task TestOllamaEmbeddingProviderMapsResponses()
{
    var handler = new FakeOllamaEmbeddingHandler();
    using var http = new HttpClient(handler)
    {
        BaseAddress = new Uri("http://ollama.test/")
    };
    using var provider = new OllamaEmbeddingProvider(http, "test-embed", batchSize: 2);

    var text = "public sealed class EmbeddedSmoke { }";
    var hash = CodeMeshHash.Sha256Hex(text);
    var node = new CodeNode(
        "csharp:type:CodeMesh.Tests.EmbeddedSmoke",
        "csharp:type:CodeMesh.Tests.EmbeddedSmoke",
        CodeNodeKind.Class,
        "EmbeddedSmoke",
        "csharp",
        "CodeMesh.Tests",
        new SourceSpan("EmbeddedSmoke.cs", 1, 1, 1, 37),
        hash,
        new Dictionary<string, string>());
    var content = new CodeContent(
        hash,
        text,
        "text/x-csharp-fragment",
        DateTimeOffset.UtcNow,
        DateTimeOffset.UtcNow);

    var embeddings = await provider.EmbedAsync(
        [node],
        new Dictionary<string, CodeContent> { [hash] = content });

    Equal(1, handler.RequestCount, "Expected one Ollama embed request.");
    Equal(1, embeddings.Count, "Expected one embedding record.");
    Equal("ollama", embeddings[0].Provider, "Ollama provider name changed.");
    Equal("test-embed", embeddings[0].Model, "Ollama embedding model changed.");
    Equal(node.Id, embeddings[0].NodeId, "Ollama embedding node id changed.");
    Equal(hash, embeddings[0].ContentHash, "Ollama embedding content hash changed.");
    Equal(3, embeddings[0].Dimensions, "Ollama embedding dimensions changed.");
    Equal("Class", embeddings[0].Metadata["kind"], "Ollama embedding kind metadata changed.");
    Equal("EmbeddedSmoke.cs", embeddings[0].Metadata["filePath"], "Ollama embedding file path metadata changed.");
    if (!handler.LastRequestBody.Contains("search_document: public sealed class EmbeddedSmoke", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("Ollama embedding request was not prefixed for document retrieval.");
    }
}

static async Task TestLmStudioEmbeddingProviderMapsResponses()
{
    var handler = new FakeLmStudioEmbeddingHandler();
    using var http = new HttpClient(handler)
    {
        BaseAddress = new Uri("http://lmstudio.test/v1/")
    };
    using var provider = new LmStudioEmbeddingProvider(http, "test-embed", batchSize: 2);

    var text = "public sealed class EmbeddedSmoke { }";
    var hash = CodeMeshHash.Sha256Hex(text);
    var node = new CodeNode(
        "csharp:type:CodeMesh.Tests.EmbeddedSmoke",
        "csharp:type:CodeMesh.Tests.EmbeddedSmoke",
        CodeNodeKind.Class,
        "EmbeddedSmoke",
        "csharp",
        "CodeMesh.Tests",
        new SourceSpan("EmbeddedSmoke.cs", 1, 1, 1, 37),
        hash,
        new Dictionary<string, string>());
    var content = new CodeContent(
        hash,
        text,
        "text/x-csharp-fragment",
        DateTimeOffset.UtcNow,
        DateTimeOffset.UtcNow);

    var embeddings = await provider.EmbedAsync(
        [node],
        new Dictionary<string, CodeContent> { [hash] = content });

    Equal(1, handler.RequestCount, "Expected one LM Studio embedding request.");
    Equal(1, embeddings.Count, "Expected one embedding record.");
    Equal("lmstudio", embeddings[0].Provider, "LM Studio provider name changed.");
    Equal("test-embed", embeddings[0].Model, "LM Studio embedding model changed.");
    Equal(node.Id, embeddings[0].NodeId, "LM Studio embedding node id changed.");
    Equal(hash, embeddings[0].ContentHash, "LM Studio embedding content hash changed.");
    Equal(3, embeddings[0].Dimensions, "LM Studio embedding dimensions changed.");
    Equal("Class", embeddings[0].Metadata["kind"], "LM Studio embedding kind metadata changed.");
    Equal("EmbeddedSmoke.cs", embeddings[0].Metadata["filePath"], "LM Studio embedding file path metadata changed.");
    if (!handler.LastRequestBody.Contains("search_document: public sealed class EmbeddedSmoke", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("LM Studio embedding request was not prefixed for document retrieval.");
    }
}

static async Task TestLmStudioSummaryProviderAcceptsNumericConfidence()
{
    var handler = new FakeLmStudioSummaryHandler();
    using var http = new HttpClient(handler)
    {
        BaseAddress = new Uri("http://lmstudio.test/v1/")
    };
    using var provider = new LmStudioCodeSummaryProvider(http, "test-summary");

    const string text = "public static string Normalize(string url) => url.Trim().ToLowerInvariant();";
    var hash = CodeMeshHash.Sha256Hex(text);
    var node = new CodeNode(
        "csharp:method:CodeMesh.Tests.EmbeddedSmoke.Normalize(System.String)",
        "csharp:method:CodeMesh.Tests.EmbeddedSmoke.Normalize(System.String)",
        CodeNodeKind.Method,
        "Normalize",
        "csharp",
        "CodeMesh.Tests",
        new SourceSpan("EmbeddedSmoke.cs", 1, 1, 1, 72),
        hash,
        new Dictionary<string, string>());
    var content = new CodeContent(
        hash,
        text,
        "text/x-csharp-fragment",
        DateTimeOffset.UtcNow,
        DateTimeOffset.UtcNow);

    var summary = await provider.SummarizeAsync(new CodeSummaryRequest(
        node,
        content,
        "node-summary-v2",
        1500,
        new SummaryBudget(
            SummaryBudgetPolicy.PolicyVersion,
            SummaryComplexityTier.Complex,
            320,
            768,
            1536,
            text.Length,
            false)));

    Equal(1, handler.RequestCount, "Expected one LM Studio summary request.");
    Equal("lmstudio", provider.Provider, "LM Studio summary provider name changed.");
    Equal("test-summary", provider.Model, "LM Studio summary model changed.");
    Equal(
        "Trims a URL and converts it to lowercase.",
        summary.Summary,
        "LM Studio summary text did not deserialize.");
    Equal("high", summary.Confidence, "LM Studio numeric confidence was not normalized.");
    Equal("normalization", summary.Tags[0], "LM Studio summary tags did not deserialize.");
    Equal(96, summary.Usage?.InputTokens ?? -1, "LM Studio summary input-token usage was not captured.");
    Equal(24, summary.Usage?.OutputTokens ?? -1, "LM Studio summary output-token usage was not captured.");
    Equal(120, summary.Usage?.TotalTokens ?? -1, "LM Studio summary total-token usage was not captured.");
    if (!handler.LastRequestBody.Contains("\"response_format\":{\"type\":\"text\"}", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("LM Studio summary request response format changed.");
    }
    if (!handler.LastRequestBody.Contains("\"max_tokens\":1536", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("LM Studio summary request ignored the selected completion ceiling.");
    }
    if (!handler.LastRequestBody.Contains("2-3 sentences", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("LM Studio summary request ignored the complex summary tier.");
    }
}

static async Task TestOllamaSummaryProviderUsesRequestCompletionBudget()
{
    var handler = new FakeOllamaSummaryHandler();
    using var http = new HttpClient(handler)
    {
        BaseAddress = new Uri("http://ollama.test/")
    };
    using var provider = new OllamaCodeSummaryProvider(http, "test-summary");

    const string text = "public int Add(int left, int right) => left + right;";
    var node = SummaryNode(
        CodeNodeKind.Method,
        "Add",
        text,
        startLine: 1,
        endLine: 1);
    var request = SummaryBudgetPolicy.CreateRequest(
        node,
        SummaryContent(text),
        "node-summary-v2");

    var summary = await provider.SummarizeAsync(request);

    Equal(1, handler.RequestCount, "Expected one Ollama summary request.");
    Equal("Adds two integers and returns their sum.", summary.Summary, "Ollama summary text did not deserialize.");
    Equal(72, summary.Usage?.InputTokens ?? -1, "Ollama summary input-token usage was not captured.");
    Equal(18, summary.Usage?.OutputTokens ?? -1, "Ollama summary output-token usage was not captured.");
    Equal(90, summary.Usage?.TotalTokens ?? -1, "Ollama summary total-token usage was not captured.");
    if (!handler.LastRequestBody.Contains("\"num_predict\":1024", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("Ollama summary request ignored the selected completion ceiling.");
    }
    if (!handler.LastRequestBody.Contains("one sentence", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("Ollama summary request ignored the compact summary tier.");
    }
}

static async Task TestOpenAiSummaryProviderUsesResponsesStructuredOutput()
{
    var handler = new FakeOpenAiSummaryHandler();
    using var http = new HttpClient(handler)
    {
        BaseAddress = new Uri("https://openai.test/v1/")
    };
    using var provider = new OpenAiCodeSummaryProvider(
        http,
        "test-api-key",
        "test-summary",
        reasoningEffort: "none");

    const string text = "public int Add(int left, int right) => left + right;";
    var node = SummaryNode(
        CodeNodeKind.Method,
        "Add",
        text,
        startLine: 1,
        endLine: 1);
    var request = SummaryBudgetPolicy.CreateRequest(
        node,
        SummaryContent(text),
        "node-summary-v2");

    var summary = await provider.SummarizeAsync(request);

    Equal(1, handler.RequestCount, "Expected one OpenAI summary request.");
    Equal("openai", provider.Provider, "OpenAI summary provider name changed.");
    Equal("test-summary", provider.Model, "OpenAI summary model changed.");
    Equal("Bearer", handler.AuthorizationScheme, "OpenAI request did not use bearer authentication.");
    Equal("test-api-key", handler.AuthorizationParameter, "OpenAI request did not use the configured API key.");
    Equal("Adds two integers and returns their sum.", summary.Summary, "OpenAI summary text did not deserialize.");
    Equal("high", summary.Confidence, "OpenAI confidence did not deserialize.");
    Equal("arithmetic", summary.Tags[0], "OpenAI summary tags did not deserialize.");
    Equal(96, summary.Usage?.InputTokens ?? -1, "OpenAI input token usage did not deserialize.");
    Equal(32, summary.Usage?.CachedInputTokens ?? -1, "OpenAI cached input token usage did not deserialize.");
    Equal(12, summary.Usage?.CacheWriteInputTokens ?? -1, "OpenAI cache-write input token usage did not deserialize.");
    Equal(24, summary.Usage?.OutputTokens ?? -1, "OpenAI output token usage did not deserialize.");
    Equal(8, summary.Usage?.ReasoningTokens ?? -1, "OpenAI reasoning token usage did not deserialize.");
    Equal(120, summary.Usage?.TotalTokens ?? -1, "OpenAI total token usage did not deserialize.");
    Equal("none", summary.ProviderMetadata?["openaiReasoningEffort"] ?? "", "OpenAI reasoning effort metadata changed.");
    Equal("none", summary.ProviderMetadata?["openaiRequestedReasoningEffort"] ?? "", "OpenAI requested reasoning effort metadata changed.");
    Equal("test-summary-snapshot", summary.ProviderMetadata?["openaiResponseModel"] ?? "", "OpenAI response model metadata changed.");
    Equal("default", summary.ProviderMetadata?["openaiServiceTier"] ?? "", "OpenAI service tier metadata changed.");
    if (!handler.LastRequestBody.Contains("\"max_output_tokens\":1024", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("OpenAI summary request ignored the selected completion ceiling.");
    }
    if (!handler.LastRequestBody.Contains("\"store\":false", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("OpenAI summary request did not disable response storage.");
    }
    if (!handler.LastRequestBody.Contains("\"reasoning\":{\"effort\":\"none\"}", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("OpenAI summary request ignored the configured reasoning effort.");
    }
    if (!handler.LastRequestBody.Contains(
            "\"format\":{\"type\":\"json_schema\",\"name\":\"codemesh_node_summary\",\"strict\":true",
            StringComparison.Ordinal))
    {
        throw new InvalidOperationException("OpenAI summary request did not use strict Structured Outputs.");
    }
    if (!handler.LastRequestBody.Contains("\"additionalProperties\":false", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("OpenAI summary schema allows unspecified properties.");
    }
    if (!handler.LastRequestBody.Contains("one sentence", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("OpenAI summary request ignored the compact summary tier.");
    }
}

static async Task TestOpenAiSummaryProviderRecordsProviderDefaultEffort()
{
    var handler = new FakeOpenAiSummaryHandler("medium");
    using var http = new HttpClient(handler)
    {
        BaseAddress = new Uri("https://openai.test/v1/")
    };
    using var provider = new OpenAiCodeSummaryProvider(http, "test-api-key", "test-summary");
    const string text = "public int Add(int left, int right) => left + right;";
    var request = SummaryBudgetPolicy.CreateRequest(
        SummaryNode(CodeNodeKind.Method, "Add", text, startLine: 1, endLine: 1),
        SummaryContent(text),
        "node-summary-v2");

    var summary = await provider.SummarizeAsync(request);

    Equal("provider-default", summary.ProviderMetadata?["openaiRequestedReasoningEffort"] ?? "", "OpenAI omitted reasoning effort was not recorded as provider-default.");
    Equal("medium", summary.ProviderMetadata?["openaiReasoningEffort"] ?? "", "OpenAI response-effective reasoning effort was not recorded.");
    if (handler.LastRequestBody.Contains("\"reasoning\":", StringComparison.Ordinal))
    {
        throw new InvalidOperationException("OpenAI request emitted reasoning when the effort was omitted.");
    }
}

static async Task TestMongoContentStoreRoundTripsContent()
{
    var store = new MongoContentStore(new MongoContentStoreOptions(
        Environment.GetEnvironmentVariable("CODEMESH_MONGO_URI") ?? "mongodb://127.0.0.1:27017",
        Environment.GetEnvironmentVariable("CODEMESH_MONGO_TEST_DATABASE") ?? "codemesh_tests",
        Environment.GetEnvironmentVariable("CODEMESH_MONGO_TEST_CONTENT_COLLECTION") ?? "content_smoke",
        TimeSpan.FromSeconds(2)));

    using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10));
    var health = await store.CheckAsync(timeout.Token);
    if (health.State != CodeMesh.Domain.Health.ComponentState.Healthy)
    {
        var detail = health.Metadata.TryGetValue("detail", out var value) ? value : health.Message;
        throw new SkipTestException($"MongoDB is not reachable: {detail}");
    }

    var text = "public sealed class MongoSmoke { }";
    var now = DateTimeOffset.UtcNow;
    var content = new CodeContent(
        CodeMeshHash.Sha256Hex(text),
        text,
        "text/x-csharp-fragment",
        now,
        now);

    await store.UpsertContentAsync(content, timeout.Token);
    var loaded = await store.GetContentAsync(content.Hash, timeout.Token);

    NotNull(loaded, "MongoDB content store did not return the inserted content.");
    Equal(content.Hash, loaded!.Hash, "MongoDB content hash changed.");
    Equal(content.Text, loaded.Text, "MongoDB content text changed.");
    Equal(content.MediaType, loaded.MediaType, "MongoDB content media type changed.");

    var repository = new RepositoryRef($"repo:mongo-smoke:{Guid.NewGuid():N}", Directory.GetCurrentDirectory());
    var staleText = "public sealed class MongoStale { }";
    var currentText = "public sealed class MongoCurrent { }";
    var staleContent = new CodeContent(
        CodeMeshHash.Sha256Hex(staleText),
        staleText,
        "text/x-csharp-fragment",
        now,
        now);
    var currentContent = new CodeContent(
        CodeMeshHash.Sha256Hex(currentText),
        currentText,
        "text/x-csharp-fragment",
        now,
        now);

    await store.UpsertContentAsync(staleContent, repository, "run:mongo-stale", now, timeout.Token);
    await store.UpsertContentAsync(currentContent, repository, "run:mongo-current", now, timeout.Token);
    await store.RemoveStaleContentAsync(repository.Id, "run:mongo-current", timeout.Token);

    IsNull(await store.GetContentAsync(staleContent.Hash, timeout.Token), "MongoDB content refresh did not remove stale content.");
    NotNull(await store.GetContentAsync(currentContent.Hash, timeout.Token), "MongoDB content refresh removed current content.");

    var incrementalRepository = new RepositoryRef($"repo:mongo-incremental:{Guid.NewGuid():N}", Directory.GetCurrentDirectory());
    var incrementalStaleText = "public sealed class MongoIncrementalStale { }";
    var incrementalCurrentText = "public sealed class MongoIncrementalCurrent { }";
    var incrementalStale = new CodeContent(
        CodeMeshHash.Sha256Hex(incrementalStaleText),
        incrementalStaleText,
        "text/x-csharp-fragment",
        now,
        now);
    var incrementalCurrent = new CodeContent(
        CodeMeshHash.Sha256Hex(incrementalCurrentText),
        incrementalCurrentText,
        "text/x-csharp-fragment",
        now,
        now);

    await store.UpsertContentAsync(incrementalStale, incrementalRepository, "run:mongo-incremental-stale", now, timeout.Token);
    await store.UpsertContentAsync(incrementalCurrent, incrementalRepository, "run:mongo-incremental-current", now, timeout.Token);

    var contentStates = await store.GetContentStatesAsync(incrementalRepository.Id, timeout.Token);
    Equal(2, contentStates.Count, "MongoDB incremental content inventory count changed.");

    await store.RemoveContentExceptAsync(
        incrementalRepository.Id,
        new HashSet<string>(StringComparer.Ordinal) { incrementalCurrent.Hash },
        timeout.Token);

    IsNull(await store.GetContentAsync(incrementalStale.Hash, timeout.Token), "MongoDB incremental cleanup did not remove stale content.");
    NotNull(await store.GetContentAsync(incrementalCurrent.Hash, timeout.Token), "MongoDB incremental cleanup removed current content.");
}

static async Task TestMongoSummaryStoreMigratesGenerationIdentity()
{
    var connectionString = Environment.GetEnvironmentVariable("CODEMESH_MONGO_URI") ?? "mongodb://127.0.0.1:27017";
    var databaseName = Environment.GetEnvironmentVariable("CODEMESH_MONGO_TEST_DATABASE") ?? "codemesh_tests";
    var collectionName = $"node_summaries_configuration_{Guid.NewGuid():N}";
    var store = new MongoNodeSummaryStore(new MongoNodeSummaryStoreOptions(
        connectionString,
        databaseName,
        collectionName,
        TimeSpan.FromSeconds(2)));

    using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(30));
    var health = await store.CheckAsync(timeout.Token);
    if (health.State != CodeMesh.Domain.Health.ComponentState.Healthy)
    {
        var detail = health.Metadata.TryGetValue("detail", out var value) ? value : health.Message;
        throw new SkipTestException($"MongoDB is not reachable: {detail}");
    }

    var client = new MongoClient(connectionString);
    var database = client.GetDatabase(databaseName);
    var collection = database.GetCollection<BsonDocument>(collectionName);

    try
    {
        var legacyIdentity = Builders<BsonDocument>.IndexKeys
            .Ascending("repositoryId")
            .Ascending("nodeId")
            .Ascending("contentHash")
            .Ascending("summaryKind")
            .Ascending("provider")
            .Ascending("model")
            .Ascending("promptVersion");
        await collection.Indexes.CreateOneAsync(
            new CreateIndexModel<BsonDocument>(
                legacyIdentity,
                new CreateIndexOptions { Name = "node_summary_identity", Unique = true }),
            cancellationToken: timeout.Token);

        const string text = "public int Add(int left, int right) => left + right;";
        var node = SummaryNode(CodeNodeKind.Method, "Add", text, startLine: 1, endLine: 1);
        var repository = new RepositoryRef($"repo:mongo-summary:{Guid.NewGuid():N}", "/mongo-summary");
        var content = new Dictionary<string, CodeContent>
        {
            [node.ContentHash] = SummaryContent(text)
        };

        var first = await new CodeSummaryGenerator(
                new CountingSummaryProvider("reasoning-effort:none"),
                store)
            .GenerateAsync(repository, "run:mongo-summary-1", [node], content, timeout.Token);
        Equal(1, first.WrittenCount, "MongoDB summary store did not write the initial configuration.");

        var second = await new CodeSummaryGenerator(
                new CountingSummaryProvider("reasoning-effort:low"),
                store)
            .GenerateAsync(repository, "run:mongo-summary-2", [node], content, timeout.Token);
        Equal(1, second.WrittenCount, "MongoDB summary store did not write the changed configuration.");
        var states = await store.GetSummaryStatesAsync(repository.Id, timeout.Token);
        Equal(1, states.Count, "MongoDB summary store retained an obsolete configuration variant.");
        Equal(
            second.Summaries[0].GenerationConfigurationFingerprint,
            states[0].GenerationConfigurationFingerprint,
            "MongoDB summary state lost the generation configuration fingerprint.");

        using var indexesCursor = await collection.Indexes.ListAsync(timeout.Token);
        var indexNames = (await indexesCursor.ToListAsync(timeout.Token))
            .Select(index => index["name"].AsString)
            .ToHashSet(StringComparer.Ordinal);
        Equal(false, indexNames.Contains("node_summary_identity"), "MongoDB summary store retained the legacy identity index.");
        Equal(true, indexNames.Contains("node_summary_identity_v2"), "MongoDB summary store did not create the generation-aware identity index.");
    }
    finally
    {
        await database.DropCollectionAsync(collectionName, timeout.Token);
    }
}

static async Task TestMongoRegistryStoreRoundTripsRepositoriesAndRuns()
{
    var unique = Guid.NewGuid().ToString("N");
    var store = new MongoRegistryStore(new MongoRegistryStoreOptions(
        Environment.GetEnvironmentVariable("CODEMESH_MONGO_URI") ?? "mongodb://127.0.0.1:27017",
        Environment.GetEnvironmentVariable("CODEMESH_MONGO_TEST_DATABASE") ?? "codemesh_tests",
        $"repositories_smoke_{unique}",
        $"ingestion_runs_smoke_{unique}",
        TimeSpan.FromSeconds(2),
        $"snapshot_projects_smoke_{unique}",
        $"snapshot_checkouts_smoke_{unique}",
        $"snapshots_smoke_{unique}",
        $"ingestion_generations_smoke_{unique}",
        $"snapshot_observations_smoke_{unique}"));

    using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10));
    var health = await store.CheckAsync(timeout.Token);
    if (health.State != CodeMesh.Domain.Health.ComponentState.Healthy)
    {
        var detail = health.Metadata.TryGetValue("detail", out var value) ? value : health.Message;
        throw new SkipTestException($"MongoDB is not reachable: {detail}");
    }

    var now = DateTimeOffset.UtcNow;
    var repository = new RepositoryIndexRecord(
        $"repo:mongo-registry:{unique}",
        Directory.GetCurrentDirectory(),
        null,
        "main",
        "abcdef",
        now.AddMinutes(-1),
        now,
        $"run:mongo-registry:{unique}",
        IngestionStage.Completed,
        "ok",
        7,
        11,
        5,
        7,
        new Dictionary<string, string>
        {
            ["alias"] = $"mongo_registry_{unique}",
            ["parserName"] = "registry-test"
        },
        $"mongo_registry_{unique}");
    var run = new IngestionRunIndexRecord(
        $"run:mongo-registry:{unique}",
        repository.RepositoryId,
        repository.RootPath,
        IngestionStage.Completed,
        now.AddSeconds(-10),
        now,
        "ok",
        "csharp",
        "registry-test-parser",
        "Sample.sln",
        null,
        false,
        false,
        "ollama",
        "nomic-embed-text-v2-moe:latest",
        7,
        11,
        5,
        2,
        new IngestionStats(
            7,
            1,
            6,
            11,
            2,
            9,
            5,
            0,
            5,
            2,
            5,
            SummaryCandidateCount: 4,
            WrittenSummaryCount: 2,
            SkippedSummaryCount: 1,
            FailedSummaryCount: 1),
        1,
        0,
        0,
        new Dictionary<string, string> { ["parsedAt"] = now.ToString("O") });

    await store.UpsertRepositoryAsync(repository, timeout.Token);
    await store.UpsertRunAsync(run, timeout.Token);
    await store.UpsertRepositoryAsync(repository with
    {
        LastRunId = $"run:mongo-registry-skip-embeddings:{unique}",
        LastSeenAt = now.AddSeconds(1),
        EmbeddingCount = null
    }, timeout.Token);

    var repositories = await store.ListRepositoriesAsync(cancellationToken: timeout.Token);
    Equal(1, repositories.Count, "MongoDB registry did not list repository.");
    Equal(repository.RepositoryId, repositories[0].RepositoryId, "MongoDB registry repository id changed.");
    Equal(repository.Alias ?? string.Empty, repositories[0].Alias ?? string.Empty, "MongoDB registry alias changed.");
    Equal(repository.Branch ?? string.Empty, repositories[0].Branch ?? string.Empty, "MongoDB registry branch changed.");
    Equal(repository.EmbeddingCount ?? 0, repositories[0].EmbeddingCount ?? 0, "MongoDB registry embedding count changed.");

    var loaded = await store.GetRepositoryAsync(repository.RepositoryId, timeout.Token);
    NotNull(loaded, "MongoDB registry did not load repository by id.");
    Equal($"run:mongo-registry-skip-embeddings:{unique}", loaded!.LastRunId ?? string.Empty, "MongoDB registry last run id changed.");
    Equal(7, loaded.EmbeddingCount ?? 0, "MongoDB registry skip-embeddings update erased the known embedding count.");

    var loadedByAlias = await store.GetRepositoryAsync(repository.Alias!, timeout.Token);
    NotNull(loadedByAlias, "MongoDB registry did not load repository by alias.");
    Equal(repository.RepositoryId, loadedByAlias!.RepositoryId, "MongoDB registry alias resolved to the wrong repository.");

    var runs = await store.ListRunsAsync(repository.RepositoryId, cancellationToken: timeout.Token);
    Equal(1, runs.Count, "MongoDB registry did not list run.");
    Equal(run.RunId, runs[0].RunId, "MongoDB registry run id changed.");
    Equal(run.ParserName, runs[0].ParserName, "MongoDB registry parser name changed.");
    Equal(run.Stats?.SkippedNodeCount ?? 0, runs[0].Stats?.SkippedNodeCount ?? 0, "MongoDB registry stats changed.");
    Equal(4, runs[0].Stats?.SummaryCandidateCount ?? -1, "MongoDB registry summary candidate stats changed.");
    Equal(2, runs[0].Stats?.WrittenSummaryCount ?? -1, "MongoDB registry written summary stats changed.");
    Equal(1, runs[0].Stats?.SkippedSummaryCount ?? -1, "MongoDB registry skipped summary stats changed.");
    Equal(1, runs[0].Stats?.FailedSummaryCount ?? -1, "MongoDB registry failed summary stats changed.");

    var checkoutId = $"chk_{unique}";
    var snapshotId = $"snp_{unique}";
    var generationId = $"gen_{unique}";
    var slotId = $"slot_{CodeMeshHash.StableId(repository.RepositoryId, SnapshotSlotKind.CheckoutCurrent.ToString(), checkoutId)}";
    var snapshot = new SnapshotIndexRecord(
        snapshotId,
        repository.RepositoryId,
        "source-view",
        "scope",
        "parser-profile",
        "graph-v1",
        SnapshotState.Staging,
        now,
        now,
        null,
        generationId,
        7,
        11,
        5,
        7);
    var generation = new IngestionGenerationRecord(
        generationId,
        repository.RepositoryId,
        checkoutId,
        snapshotId,
        IngestionGenerationState.Staging,
        now,
        null,
        null);
    await store.StageGenerationAsync(generation, snapshot, timeout.Token);
    var publication = await store.PublishSnapshotAsync(
        new SnapshotPublication(
            new ProjectIdentityRecord(repository.RepositoryId, repository.Alias!, null, now, now),
            new CheckoutIdentityRecord(checkoutId, repository.RepositoryId, repository.RootPath, now, now),
            snapshot,
            new SnapshotObservationRecord($"obs_{unique}", repository.RepositoryId, checkoutId, snapshotId, "main", "abcdef", false, now, "test", run.RunId),
            generation,
            [new SnapshotSlotRecord(slotId, repository.RepositoryId, SnapshotSlotKind.CheckoutCurrent, checkoutId, snapshotId, 0, now)],
            [new SnapshotSlotExpectation(slotId, null, null)],
            TimeSpan.Zero),
        timeout.Token);
    Equal(true, publication.Published, "MongoDB snapshot publication failed.");
    Equal(snapshotId, (await store.ResolveSlotAsync(repository.RepositoryId, SnapshotSlotKind.CheckoutCurrent, checkoutId, timeout.Token))?.SnapshotId ?? string.Empty, "MongoDB snapshot slot did not resolve.");
    Equal(SnapshotState.Active, (await store.GetSnapshotAsync(snapshotId, timeout.Token))?.State ?? SnapshotState.Failed, "MongoDB snapshot was not activated.");

    await store.DeleteRepositoryAsync(repository.RepositoryId, timeout.Token);
    IsNull(await store.GetRepositoryAsync(repository.RepositoryId, timeout.Token), "MongoDB registry did not delete repository by id.");
    IsNull(await store.GetRepositoryAsync(repository.Alias!, timeout.Token), "MongoDB registry did not delete repository alias.");
    runs = await store.ListRunsAsync(repository.RepositoryId, cancellationToken: timeout.Token);
    Equal(0, runs.Count, "MongoDB registry did not delete repository runs.");
}

static async Task TestNeo4jGraphStoreRoundTripsGraph()
{
    var uri = Environment.GetEnvironmentVariable("CODEMESH_NEO4J_URI") ?? "bolt://127.0.0.1:7687";
    var user = Environment.GetEnvironmentVariable("CODEMESH_NEO4J_USER") ?? "neo4j";
    var password = Environment.GetEnvironmentVariable("CODEMESH_NEO4J_PASSWORD") ?? "codemesh";
    var database = Environment.GetEnvironmentVariable("CODEMESH_NEO4J_DATABASE") ?? "neo4j";

    await using var store = new Neo4jGraphStore(new Neo4jGraphStoreOptions(uri, user, password, database));

    using var timeout = new CancellationTokenSource();
    CancellationToken OperationToken()
    {
        timeout.CancelAfter(TimeSpan.FromSeconds(15));
        return timeout.Token;
    }

    var health = await store.CheckAsync(OperationToken());
    if (health.State != CodeMesh.Domain.Health.ComponentState.Healthy)
    {
        var detail = health.Metadata.TryGetValue("detail", out var value) ? value : health.Message;
        throw new SkipTestException($"Neo4j is not reachable: {detail}");
    }

    var unique = Guid.NewGuid().ToString("N");
    var repository = new RepositoryRef($"repo:neo4j-smoke:{unique}", Directory.GetCurrentDirectory());
    var now = DateTimeOffset.UtcNow;
    var source = new CodeNode(
        "csharp:type:CodeMesh.Tests.Neo4jSmokeSource",
        "csharp:type:CodeMesh.Tests.Neo4jSmokeSource",
        CodeNodeKind.Class,
        "Neo4jSmokeSource",
        "csharp",
        "CodeMesh.Tests",
        new SourceSpan("Neo4jSmoke.cs", 1, 1, 3, 1),
        CodeMeshHash.Sha256Hex("source"),
        new Dictionary<string, string> { ["test"] = "neo4j" });
    var target = new CodeNode(
        "csharp:type:CodeMesh.Tests.Neo4jSmokeTarget",
        "csharp:type:CodeMesh.Tests.Neo4jSmokeTarget",
        CodeNodeKind.Class,
        "Neo4jSmokeTarget",
        "csharp",
        "CodeMesh.Tests",
        new SourceSpan("Neo4jSmoke.cs", 5, 1, 7, 1),
        CodeMeshHash.Sha256Hex("target"),
        new Dictionary<string, string> { ["test"] = "neo4j" });
    var relationship = new CodeRelationship(
        CodeMeshHash.StableId(source.Id, target.Id, CodeRelationshipKind.Contains.ToString()),
        source.Id,
        target.Id,
        CodeRelationshipKind.Contains,
        "contains",
        new Dictionary<string, string> { ["test"] = "neo4j" });

    await store.UpsertGraphAsync(new CodeGraphBatch(
        "batch:neo4j-smoke",
        repository,
        [source, target],
        [relationship],
        Array.Empty<CodeContent>(),
        now), OperationToken());

    var loaded = await store.GetNodeAsync(source.Id, OperationToken());
    NotNull(loaded, "Neo4j graph store did not return the inserted node.");
    Equal(source.Id, loaded!.Id, "Neo4j node id changed.");
    Equal(source.Kind, loaded.Kind, "Neo4j node kind changed.");
    Equal(source.Metadata["test"], loaded.Metadata["test"], "Neo4j node metadata changed.");

    var relationships = await store.GetRelationshipsAsync(source.Id, cancellationToken: OperationToken());
    var loadedRelationship = relationships.SingleOrDefault(item => item.Id == relationship.Id);
    NotNull(loadedRelationship, "Neo4j graph store did not return the inserted relationship.");
    Equal(relationship.SourceNodeId, loadedRelationship!.SourceNodeId, "Neo4j relationship source changed.");
    Equal(relationship.TargetNodeId, loadedRelationship.TargetNodeId, "Neo4j relationship target changed.");
    Equal(relationship.Kind, loadedRelationship.Kind, "Neo4j relationship kind changed.");
    Equal(relationship.Metadata["test"], loadedRelationship.Metadata["test"], "Neo4j relationship metadata changed.");

    var collisionRepositoryA = new RepositoryRef($"repo:neo4j-collision-a:{unique}", Directory.GetCurrentDirectory());
    var collisionRepositoryB = new RepositoryRef($"repo:neo4j-collision-b:{unique}", Directory.GetCurrentDirectory());
    var sharedSourceId = $"csharp:type:CodeMesh.Tests.SharedSource{unique}";
    var sharedTargetId = $"csharp:type:CodeMesh.Tests.SharedTarget{unique}";
    var sharedRelationshipId = CodeMeshHash.StableId(sharedSourceId, sharedTargetId, CodeRelationshipKind.Contains.ToString());
    var collisionSourceA = source with
    {
        Id = sharedSourceId,
        StableKey = sharedSourceId,
        Name = $"SharedSource{unique}",
        Project = "CollisionProjectA",
        ContentHash = CodeMeshHash.Sha256Hex($"source-a-{unique}"),
        Metadata = new Dictionary<string, string> { ["repoMarker"] = "a" }
    };
    var collisionSourceB = collisionSourceA with
    {
        Project = "CollisionProjectB",
        ContentHash = CodeMeshHash.Sha256Hex($"source-b-{unique}"),
        Metadata = new Dictionary<string, string> { ["repoMarker"] = "b" }
    };
    var collisionTargetA = target with
    {
        Id = sharedTargetId,
        StableKey = sharedTargetId,
        Name = $"SharedTarget{unique}",
        Project = "CollisionProjectA",
        ContentHash = CodeMeshHash.Sha256Hex($"target-a-{unique}"),
        Metadata = new Dictionary<string, string> { ["repoMarker"] = "a" }
    };
    var collisionTargetB = collisionTargetA with
    {
        Project = "CollisionProjectB",
        ContentHash = CodeMeshHash.Sha256Hex($"target-b-{unique}"),
        Metadata = new Dictionary<string, string> { ["repoMarker"] = "b" }
    };
    var collisionRelationshipA = new CodeRelationship(
        sharedRelationshipId,
        sharedSourceId,
        sharedTargetId,
        CodeRelationshipKind.Contains,
        "contains",
        new Dictionary<string, string> { ["repoMarker"] = "a" });
    var collisionRelationshipB = collisionRelationshipA with
    {
        Metadata = new Dictionary<string, string> { ["repoMarker"] = "b" }
    };

    await store.UpsertGraphAsync(new CodeGraphBatch(
        "run:neo4j-collision-a",
        collisionRepositoryA,
        [collisionSourceA, collisionTargetA],
        [collisionRelationshipA],
        Array.Empty<CodeContent>(),
        now), OperationToken());
    await store.UpsertGraphAsync(new CodeGraphBatch(
        "run:neo4j-collision-b",
        collisionRepositoryB,
        [collisionSourceB, collisionTargetB],
        [collisionRelationshipB],
        Array.Empty<CodeContent>(),
        now), OperationToken());

    var loadedCollisionA = await store.GetNodeAsync(sharedSourceId, collisionRepositoryA.Id, OperationToken());
    var loadedCollisionB = await store.GetNodeAsync(sharedSourceId, collisionRepositoryB.Id, OperationToken());
    NotNull(loadedCollisionA, "Neo4j did not return repository A's colliding node.");
    NotNull(loadedCollisionB, "Neo4j did not return repository B's colliding node.");
    Equal("CollisionProjectA", loadedCollisionA!.Project, "Neo4j repository A node was overwritten by repository B.");
    Equal("CollisionProjectB", loadedCollisionB!.Project, "Neo4j repository B node was not stored separately.");
    Equal("a", loadedCollisionA.Metadata["repoMarker"], "Neo4j repository A node metadata changed.");
    Equal("b", loadedCollisionB.Metadata["repoMarker"], "Neo4j repository B node metadata changed.");

    var collisionRelationshipsA = await store.GetRelationshipsAsync(sharedSourceId, collisionRepositoryA.Id, cancellationToken: OperationToken());
    var collisionRelationshipsB = await store.GetRelationshipsAsync(sharedSourceId, collisionRepositoryB.Id, cancellationToken: OperationToken());
    var loadedCollisionRelationshipA = collisionRelationshipsA.SingleOrDefault(item => item.Id == sharedRelationshipId);
    var loadedCollisionRelationshipB = collisionRelationshipsB.SingleOrDefault(item => item.Id == sharedRelationshipId);
    NotNull(loadedCollisionRelationshipA, "Neo4j did not return repository A's colliding relationship.");
    NotNull(loadedCollisionRelationshipB, "Neo4j did not return repository B's colliding relationship.");
    Equal("a", loadedCollisionRelationshipA!.Metadata["repoMarker"], "Neo4j repository A relationship was overwritten by repository B.");
    Equal("b", loadedCollisionRelationshipB!.Metadata["repoMarker"], "Neo4j repository B relationship was not stored separately.");

    var stale = source with
    {
        Id = $"csharp:type:CodeMesh.Tests.Neo4jStale{unique}",
        StableKey = $"csharp:type:CodeMesh.Tests.Neo4jStale{unique}",
        Name = $"Neo4jStale{unique}"
    };
    var current = target with
    {
        Id = $"csharp:type:CodeMesh.Tests.Neo4jCurrent{unique}",
        StableKey = $"csharp:type:CodeMesh.Tests.Neo4jCurrent{unique}",
        Name = $"Neo4jCurrent{unique}"
    };

    await store.UpsertGraphAsync(new CodeGraphBatch(
        "run:neo4j-stale",
        repository,
        [stale],
        Array.Empty<CodeRelationship>(),
        Array.Empty<CodeContent>(),
        now), OperationToken());
    await store.UpsertGraphAsync(new CodeGraphBatch(
        "run:neo4j-current",
        repository,
        [current],
        Array.Empty<CodeRelationship>(),
        Array.Empty<CodeContent>(),
        now), OperationToken());
    await store.RemoveStaleGraphAsync(repository.Id, "run:neo4j-current", OperationToken());

    IsNull(await store.GetNodeAsync(stale.Id, OperationToken()), "Neo4j graph refresh did not remove stale node.");
    NotNull(await store.GetNodeAsync(current.Id, OperationToken()), "Neo4j graph refresh removed current node.");

    var incrementalRepository = new RepositoryRef($"repo:neo4j-incremental:{unique}", Directory.GetCurrentDirectory());
    var incrementalStale = source with
    {
        Id = $"csharp:type:CodeMesh.Tests.Neo4jIncrementalStale{unique}",
        StableKey = $"csharp:type:CodeMesh.Tests.Neo4jIncrementalStale{unique}",
        Name = $"Neo4jIncrementalStale{unique}"
    };
    var incrementalCurrent = target with
    {
        Id = $"csharp:type:CodeMesh.Tests.Neo4jIncrementalCurrent{unique}",
        StableKey = $"csharp:type:CodeMesh.Tests.Neo4jIncrementalCurrent{unique}",
        Name = $"Neo4jIncrementalCurrent{unique}"
    };
    var incrementalRelationship = new CodeRelationship(
        CodeMeshHash.StableId(incrementalStale.Id, incrementalCurrent.Id, CodeRelationshipKind.Contains.ToString()),
        incrementalStale.Id,
        incrementalCurrent.Id,
        CodeRelationshipKind.Contains,
        "contains",
        new Dictionary<string, string> { ["test"] = "neo4j-incremental" });

    await store.UpsertGraphAsync(new CodeGraphBatch(
        "run:neo4j-incremental",
        incrementalRepository,
        [incrementalStale, incrementalCurrent],
        [incrementalRelationship],
        Array.Empty<CodeContent>(),
        now), OperationToken());

    var nodeStates = await store.GetNodeStatesAsync(incrementalRepository.Id, OperationToken());
    var relationshipStates = await store.GetRelationshipStatesAsync(incrementalRepository.Id, OperationToken());
    Equal(2, nodeStates.Count, "Neo4j incremental node inventory count changed.");
    Equal(1, relationshipStates.Count, "Neo4j incremental relationship inventory count changed.");

    await store.RemoveGraphExceptAsync(
        incrementalRepository.Id,
        new HashSet<string>(StringComparer.Ordinal) { incrementalCurrent.Id },
        new HashSet<string>(StringComparer.Ordinal),
        OperationToken());

    IsNull(await store.GetNodeAsync(incrementalStale.Id, OperationToken()), "Neo4j incremental cleanup did not remove stale node.");
    NotNull(await store.GetNodeAsync(incrementalCurrent.Id, OperationToken()), "Neo4j incremental cleanup removed current node.");

    var emptyIds = new HashSet<string>(StringComparer.Ordinal);
    foreach (var repositoryId in new[]
             {
                 repository.Id,
                 collisionRepositoryA.Id,
                 collisionRepositoryB.Id,
                 incrementalRepository.Id
             })
    {
        await store.RemoveGraphExceptAsync(
            repositoryId,
            emptyIds,
            emptyIds,
            OperationToken());
    }
}

static async Task TestQdrantVectorStoreRoundTripsEmbeddings()
{
    var url = Environment.GetEnvironmentVariable("CODEMESH_QDRANT_URL") ?? "http://127.0.0.1:6333";
    var configuredCollection = Environment.GetEnvironmentVariable("CODEMESH_QDRANT_TEST_COLLECTION");
    var collection = string.IsNullOrWhiteSpace(configuredCollection)
        ? $"codemesh_tests_vectors_{Guid.NewGuid():N}"
        : configuredCollection;

    try
    {
        using var store = new QdrantVectorStore(new QdrantVectorStoreOptions(url, collection, Timeout: TimeSpan.FromSeconds(2)));

        using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10));
        var health = await store.CheckAsync(timeout.Token);
        if (health.State != CodeMesh.Domain.Health.ComponentState.Healthy)
        {
            var detail = health.Metadata.TryGetValue("detail", out var value) ? value : health.Message;
            throw new SkipTestException($"Qdrant is not reachable: {detail}");
        }

        var unique = Guid.NewGuid().ToString("N");
        var first = new EmbeddingRecord(
            $"embedding:qdrant:{unique}:alpha",
            $"node:qdrant:{unique}:alpha",
            $"hash:qdrant:{unique}:alpha",
            "test",
            "unit",
            3,
            [1.0f, 0.0f, 0.0f],
            new Dictionary<string, string>
            {
                ["preview"] = "alpha vector",
                ["smokeTest"] = unique
            });
        var second = new EmbeddingRecord(
            $"embedding:qdrant:{unique}:beta",
            $"node:qdrant:{unique}:beta",
            $"hash:qdrant:{unique}:beta",
            "test",
            "unit",
            3,
            [0.0f, 1.0f, 0.0f],
            new Dictionary<string, string>
            {
                ["preview"] = "beta vector",
                ["smokeTest"] = unique
            });

        await store.UpsertEmbeddingsAsync([first, second], timeout.Token);

        var matches = await store.SearchAsync(
            [1.0f, 0.0f, 0.0f],
            2,
            new Dictionary<string, string> { ["smokeTest"] = unique },
            timeout.Token);

        if (matches.Count == 0)
        {
            throw new InvalidOperationException("Qdrant vector store returned no matches.");
        }

        Equal(first.NodeId, matches[0].NodeId, "Qdrant nearest match node id changed.");
        Equal(first.ContentHash, matches[0].ContentHash, "Qdrant nearest match content hash changed.");
        Equal("alpha vector", matches[0].Preview ?? string.Empty, "Qdrant nearest match preview changed.");
        Equal(unique, matches[0].Metadata["smokeTest"], "Qdrant nearest match metadata changed.");

        var collisionRepositoryA = $"repo:qdrant-collision-a:{unique}";
        var collisionRepositoryB = $"repo:qdrant-collision-b:{unique}";
        var sharedEmbeddingId = $"embedding:qdrant:{unique}:shared";
        var sharedNodeId = $"node:qdrant:{unique}:shared";
        var collisionA = new EmbeddingRecord(
            sharedEmbeddingId,
            sharedNodeId,
            $"hash:qdrant:{unique}:collision-a",
            "test",
            "unit",
            3,
            [0.5f, 0.5f, 0.0f],
            new Dictionary<string, string>
            {
                ["repositoryId"] = collisionRepositoryA,
                ["preview"] = "collision vector a"
            });
        var collisionB = new EmbeddingRecord(
            sharedEmbeddingId,
            sharedNodeId,
            $"hash:qdrant:{unique}:collision-b",
            "test",
            "unit",
            3,
            [0.5f, 0.5f, 0.0f],
            new Dictionary<string, string>
            {
                ["repositoryId"] = collisionRepositoryB,
                ["preview"] = "collision vector b"
            });

        await store.UpsertEmbeddingsAsync([collisionA, collisionB], timeout.Token);

        var collisionMatchesA = await store.SearchAsync(
            [0.5f, 0.5f, 0.0f],
            1,
            new Dictionary<string, string> { ["repositoryId"] = collisionRepositoryA },
            timeout.Token);
        var collisionMatchesB = await store.SearchAsync(
            [0.5f, 0.5f, 0.0f],
            1,
            new Dictionary<string, string> { ["repositoryId"] = collisionRepositoryB },
            timeout.Token);

        Equal(1, collisionMatchesA.Count, "Qdrant did not retain repository A's colliding embedding.");
        Equal(1, collisionMatchesB.Count, "Qdrant did not retain repository B's colliding embedding.");
        Equal(collisionA.ContentHash, collisionMatchesA[0].ContentHash, "Qdrant repository A embedding was overwritten by repository B.");
        Equal(collisionB.ContentHash, collisionMatchesB[0].ContentHash, "Qdrant repository B embedding was not stored separately.");
        Equal("collision vector a", collisionMatchesA[0].Preview ?? string.Empty, "Qdrant repository A preview changed.");
        Equal("collision vector b", collisionMatchesB[0].Preview ?? string.Empty, "Qdrant repository B preview changed.");

        var repositoryId = $"repo:qdrant:{unique}";
        var stale = new EmbeddingRecord(
            $"embedding:qdrant:{unique}:stale",
            $"node:qdrant:{unique}:stale",
            $"hash:qdrant:{unique}:stale",
            "test",
            "unit",
            3,
            [0.0f, 0.0f, 1.0f],
            new Dictionary<string, string>
            {
                ["repositoryId"] = repositoryId,
                ["ingestionRunId"] = "run:qdrant-stale",
                ["preview"] = "stale vector"
            });
        var current = new EmbeddingRecord(
            $"embedding:qdrant:{unique}:current",
            $"node:qdrant:{unique}:current",
            $"hash:qdrant:{unique}:current",
            "test",
            "unit",
            3,
            [0.0f, 0.0f, 1.0f],
            new Dictionary<string, string>
            {
                ["repositoryId"] = repositoryId,
                ["ingestionRunId"] = "run:qdrant-current",
                ["preview"] = "current vector"
            });

        await store.UpsertEmbeddingsAsync([stale, current], timeout.Token);
        await store.RemoveStaleEmbeddingsAsync(repositoryId, "run:qdrant-current", timeout.Token);

        var refreshMatches = await store.SearchAsync(
            [0.0f, 0.0f, 1.0f],
            10,
            new Dictionary<string, string> { ["repositoryId"] = repositoryId },
            timeout.Token);
        if (refreshMatches.Any(match => string.Equals(match.NodeId, stale.NodeId, StringComparison.Ordinal)))
        {
            throw new InvalidOperationException("Qdrant vector refresh did not remove stale embedding.");
        }

        if (!refreshMatches.Any(match => string.Equals(match.NodeId, current.NodeId, StringComparison.Ordinal)))
        {
            throw new InvalidOperationException("Qdrant vector refresh removed current embedding.");
        }

        var incrementalRepositoryId = $"repo:qdrant-incremental:{unique}";
        var incrementalStale = new EmbeddingRecord(
            $"embedding:qdrant:{unique}:incremental-stale",
            $"node:qdrant:{unique}:incremental-stale",
            $"hash:qdrant:{unique}:incremental-stale",
            "test",
            "unit",
            3,
            [0.0f, 0.0f, 1.0f],
            new Dictionary<string, string>
            {
                ["repositoryId"] = incrementalRepositoryId,
                ["preview"] = "incremental stale vector"
            });
        var incrementalCurrent = new EmbeddingRecord(
            $"embedding:qdrant:{unique}:incremental-current",
            $"node:qdrant:{unique}:incremental-current",
            $"hash:qdrant:{unique}:incremental-current",
            "test",
            "unit",
            3,
            [0.0f, 0.0f, 1.0f],
            new Dictionary<string, string>
            {
                ["repositoryId"] = incrementalRepositoryId,
                ["preview"] = "incremental current vector"
            });

        await store.UpsertEmbeddingsAsync([incrementalStale, incrementalCurrent], timeout.Token);

        var embeddingStates = await store.GetEmbeddingStatesAsync(incrementalRepositoryId, timeout.Token);
        Equal(2, embeddingStates.Count, "Qdrant incremental embedding inventory count changed.");

        await store.RemoveEmbeddingsExceptAsync(
            incrementalRepositoryId,
            new HashSet<string>(StringComparer.Ordinal) { incrementalCurrent.Id },
            timeout.Token);

        var incrementalMatches = await store.SearchAsync(
            [0.0f, 0.0f, 1.0f],
            10,
            new Dictionary<string, string> { ["repositoryId"] = incrementalRepositoryId },
            timeout.Token);
        if (incrementalMatches.Any(match => string.Equals(match.NodeId, incrementalStale.NodeId, StringComparison.Ordinal)))
        {
            throw new InvalidOperationException("Qdrant incremental cleanup did not remove stale embedding.");
        }

        if (!incrementalMatches.Any(match => string.Equals(match.NodeId, incrementalCurrent.NodeId, StringComparison.Ordinal)))
        {
            throw new InvalidOperationException("Qdrant incremental cleanup removed current embedding.");
        }
    }
    finally
    {
        if (string.IsNullOrWhiteSpace(configuredCollection))
        {
            await DeleteQdrantCollectionAsync(url, collection);
        }
    }
}

static async Task TestCSharpParserEmitsRoslynSymbols()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-parser-test-{Guid.NewGuid():N}");
    Directory.CreateDirectory(root);

    try
    {
        await File.WriteAllTextAsync(
            Path.Combine(root, "Demo.cs"),
            """
            namespace Sample;

            public interface IWorker
            {
                Demo Create(Demo input, int count);
            }

            public abstract class BaseWorker
            {
                public abstract Demo Create(Demo input, int count);
            }

            public sealed class DemoWorker : BaseWorker, IWorker
            {
                public override Demo Create(Demo input, int count) => input;
            }

            public sealed class Demo
            {
                public int Count { get; init; }
            }
            """);

        var parser = new CSharpParseService();
        var result = await parser.ParseAsync(new ParseRequest(
            root,
            null,
            null,
            "csharp",
            new Dictionary<string, string>()));

        var errors = result.Diagnostics
            .Where(diagnostic => string.Equals(diagnostic.Severity, "error", StringComparison.OrdinalIgnoreCase))
            .Select(diagnostic => diagnostic.Message)
            .ToArray();

        if (errors.Length > 0)
        {
            throw new InvalidOperationException($"Parser returned errors: {string.Join("; ", errors)}");
        }

        HasNode(result, CodeNodeKind.Namespace, "Sample");
        HasNode(result, CodeNodeKind.Interface, "IWorker");
        HasNode(result, CodeNodeKind.Class, "DemoWorker");
        HasNode(result, CodeNodeKind.Method, "Create");
        HasNode(result, CodeNodeKind.Parameter, "count");
        HasNode(result, CodeNodeKind.Property, "Count");
        HasNode(result, CodeNodeKind.Declaration, "DemoWorker");
        HasNodeId(result, "csharp:file:Demo.cs");
        HasNodeId(result, "csharp:namespace:Sample");
        HasNodeId(result, "csharp:type:Sample.DemoWorker");
        HasNodeId(result, "csharp:decl:csharp:type:Sample.DemoWorker:Demo.cs:13:1");
        HasNodeId(result, "csharp:method:Sample.DemoWorker.Create(Sample.Demo,System.Int32)");
        HasNodeId(result, "csharp:param:Sample.DemoWorker.Create(Sample.Demo,System.Int32):0:input");
        HasNodeId(result, "csharp:property:Sample.Demo.Count");

        HasRelationship(result, CodeRelationshipKind.Contains);
        HasRelationship(result, CodeRelationshipKind.Inherits);
        HasRelationship(result, CodeRelationshipKind.Implements);
        HasRelationship(result, CodeRelationshipKind.Returns);
        HasRelationship(result, CodeRelationshipKind.Overrides);
        HasRelationship(result, CodeRelationshipKind.UsesType);
        HasRelationshipBetween(
            result,
            "csharp:decl:csharp:type:Sample.DemoWorker:Demo.cs:13:1",
            "csharp:type:Sample.DemoWorker",
            CodeRelationshipKind.Defines);
        HasRelationshipBetween(
            result,
            "csharp:type:Sample.DemoWorker",
            "csharp:method:Sample.DemoWorker.Create(Sample.Demo,System.Int32)",
            CodeRelationshipKind.Contains);
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static async Task TestCSharpParserEmitsTestFilesAndCases()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-parser-tests-test-{Guid.NewGuid():N}");
    var testsDirectory = Path.Combine(root, "tests", "Sample.Tests");
    Directory.CreateDirectory(testsDirectory);

    try
    {
        await File.WriteAllTextAsync(
            Path.Combine(testsDirectory, "WorkerTests.cs"),
            """
            namespace Sample.Tests;

            public sealed class WorkerTests
            {
                [Fact]
                public void Parses_named_test_attribute()
                {
                }

                public void TestConventionBasedHarnessCase()
                {
                }

                public void Helper()
                {
                }
            }
            """);

        var parser = new CSharpParseService();
        var result = await parser.ParseAsync(new ParseRequest(
            root,
            null,
            null,
            "csharp",
            new Dictionary<string, string>()));

        var errors = result.Diagnostics
            .Where(diagnostic => string.Equals(diagnostic.Severity, "error", StringComparison.OrdinalIgnoreCase))
            .Select(diagnostic => diagnostic.Message)
            .ToArray();

        if (errors.Length > 0)
        {
            throw new InvalidOperationException($"Parser returned errors: {string.Join("; ", errors)}");
        }

        HasNode(result, CodeNodeKind.TestFile, "WorkerTests.cs");
        HasNode(result, CodeNodeKind.TestCase, "Parses_named_test_attribute");
        HasNode(result, CodeNodeKind.TestCase, "TestConventionBasedHarnessCase");
        HasNode(result, CodeNodeKind.Method, "Helper");

        var attributedTest = result.Nodes.Single(node =>
            node.Kind == CodeNodeKind.TestCase &&
            string.Equals(node.Name, "Parses_named_test_attribute", StringComparison.Ordinal));
        Equal("case", attributedTest.Metadata["testRole"], "C# parser did not tag attributed test case role.");
        Equal("xunit", attributedTest.Metadata["testFramework"], "C# parser did not infer xUnit test framework.");

        var conventionTest = result.Nodes.Single(node =>
            node.Kind == CodeNodeKind.TestCase &&
            string.Equals(node.Name, "TestConventionBasedHarnessCase", StringComparison.Ordinal));
        Equal("case", conventionTest.Metadata["testRole"], "C# parser did not tag convention test case role.");
        Equal("convention", conventionTest.Metadata["testFramework"], "C# parser did not tag convention-based test framework.");

        HasRelationshipBetween(
            result,
            "csharp:type:Sample.Tests.WorkerTests",
            "csharp:method:Sample.Tests.WorkerTests.Parses_named_test_attribute()",
            CodeRelationshipKind.Contains);
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static async Task TestCSharpParserEmitsInvocationAndMemberAccessRelationships()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-parser-calls-test-{Guid.NewGuid():N}");
    Directory.CreateDirectory(root);

    try
    {
        await File.WriteAllTextAsync(
            Path.Combine(root, "Calls.cs"),
            """
            namespace Sample;

            public sealed class Worker
            {
                private int _count;

                public int Count
                {
                    get => _count;
                    set => _count = value;
                }

                public void Run()
                {
                    Count = Helper();
                }

                private int Helper()
                {
                    return Count;
                }
            }
            """);

        var parser = new CSharpParseService();
        var result = await parser.ParseAsync(new ParseRequest(
            root,
            null,
            null,
            "csharp",
            new Dictionary<string, string>()));

        var errors = result.Diagnostics
            .Where(diagnostic => string.Equals(diagnostic.Severity, "error", StringComparison.OrdinalIgnoreCase))
            .Select(diagnostic => diagnostic.Message)
            .ToArray();

        if (errors.Length > 0)
        {
            throw new InvalidOperationException($"Parser returned errors: {string.Join("; ", errors)}");
        }

        const string run = "csharp:method:Sample.Worker.Run()";
        const string helper = "csharp:method:Sample.Worker.Helper()";
        const string count = "csharp:property:Sample.Worker.Count";
        const string field = "csharp:field:Sample.Worker._count";

        HasRelationshipBetween(result, run, helper, CodeRelationshipKind.Invokes);
        HasRelationshipBetween(result, run, count, CodeRelationshipKind.Writes);
        HasRelationshipBetween(result, helper, count, CodeRelationshipKind.Reads);
        HasRelationshipBetween(result, count, field, CodeRelationshipKind.Reads);
        HasRelationshipBetween(result, count, field, CodeRelationshipKind.Writes);
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static async Task TestCSharpParserEmitsCrossProjectInvocationRelationships()
{
    var root = Path.Combine(
        Path.GetTempPath(),
        $"codemesh-parser-cross-project-test-{Guid.NewGuid():N}");
    var coreRoot = Path.Combine(root, "Sample.Core");
    var appRoot = Path.Combine(root, "Sample.App");
    Directory.CreateDirectory(coreRoot);
    Directory.CreateDirectory(appRoot);

    try
    {
        var solutionPath = Path.Combine(root, "Sample.slnx");
        await File.WriteAllTextAsync(
            solutionPath,
            """
            <Solution>
              <Project Path="Sample.App/Sample.App.csproj" />
              <Project Path="Sample.Core/Sample.Core.csproj" />
            </Solution>
            """);
        await File.WriteAllTextAsync(
            Path.Combine(coreRoot, "Sample.Core.csproj"),
            """
            <Project Sdk="Microsoft.NET.Sdk">
              <PropertyGroup>
                <TargetFramework>net10.0</TargetFramework>
              </PropertyGroup>
            </Project>
            """);
        await File.WriteAllTextAsync(
            Path.Combine(appRoot, "Sample.App.csproj"),
            """
            <Project Sdk="Microsoft.NET.Sdk">
              <PropertyGroup>
                <TargetFramework>net10.0</TargetFramework>
              </PropertyGroup>
              <ItemGroup>
                <ProjectReference Include="../Sample.Core/Sample.Core.csproj" />
              </ItemGroup>
            </Project>
            """);
        await File.WriteAllTextAsync(
            Path.Combine(coreRoot, "Downloader.cs"),
            """
            namespace Sample.Core;

            public sealed class Downloader
            {
                public void Download(string path)
                {
                }
            }
            """);
        await File.WriteAllTextAsync(
            Path.Combine(appRoot, "Dashboard.cs"),
            """
            using Sample.Core;

            namespace Sample.App;

            public sealed class Dashboard
            {
                public void Run(Downloader downloader)
                {
                    downloader.Download("output.mp4");
                }
            }
            """);

        var hook = System.Security.SecurityElement.Escape(Path.Combine(AppContext.BaseDirectory, "CodeMesh.DesignTime.targets"));
        foreach (var projectFile in Directory.EnumerateFiles(root, "*.csproj", SearchOption.AllDirectories))
        {
            var projectText = await File.ReadAllTextAsync(projectFile);
            await File.WriteAllTextAsync(projectFile,
                projectText.Replace("</Project>", $"<Import Project=\"{hook}\" /></Project>", StringComparison.Ordinal));
        }

        var parser = new CSharpParseService();
        var result = await parser.ParseAsync(new ParseRequest(
            root,
            solutionPath,
            null,
            "csharp",
            new Dictionary<string, string>()));

        var errors = result.Diagnostics
            .Where(diagnostic => string.Equals(
                diagnostic.Severity,
                "error",
                StringComparison.OrdinalIgnoreCase))
            .Select(diagnostic => diagnostic.Message)
            .ToArray();
        if (errors.Length > 0)
        {
            throw new InvalidOperationException(
                $"Parser returned errors: {string.Join("; ", errors)}");
        }

        HasRelationshipBetween(
            result,
            "csharp:method:Sample.App.Dashboard.Run(Sample.Core.Downloader)",
            "csharp:method:Sample.Core.Downloader.Download(System.String)",
            CodeRelationshipKind.Invokes);
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static async Task TestCSharpParserSeparatesPartialDeclarations()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-parser-partial-test-{Guid.NewGuid():N}");
    Directory.CreateDirectory(root);

    try
    {
        await File.WriteAllTextAsync(
            Path.Combine(root, "Customer.Validation.cs"),
            """
            namespace Sample;

            public sealed partial class Customer
            {
                public bool IsValid() => !string.IsNullOrWhiteSpace(Name);
            }
            """);

        await File.WriteAllTextAsync(
            Path.Combine(root, "Customer.cs"),
            """
            namespace Sample;

            public sealed partial class Customer
            {
                public string Name { get; set; } = "";
            }
            """);

        var parser = new CSharpParseService();
        var result = await parser.ParseAsync(new ParseRequest(
            root,
            null,
            null,
            "csharp",
            new Dictionary<string, string>()));

        Equal(1, result.Nodes.Count(node => string.Equals(node.Id, "csharp:type:Sample.Customer", StringComparison.Ordinal)), "Expected one logical Customer type node.");
        Equal(
            "Customer.cs",
            result.Nodes.Single(node => string.Equals(node.Id, "csharp:type:Sample.Customer", StringComparison.Ordinal)).Span.FilePath,
            "The logical Customer type should use the canonical main declaration path.");
        Equal(2, result.Nodes.Count(node =>
            node.Kind == CodeNodeKind.Declaration &&
            node.Metadata.TryGetValue("symbolId", out var symbolId) &&
            string.Equals(symbolId, "csharp:type:Sample.Customer", StringComparison.Ordinal)), "Expected two Customer declaration nodes.");

        HasRelationshipBetween(
            result,
            "csharp:decl:csharp:type:Sample.Customer:Customer.cs:3:1",
            "csharp:type:Sample.Customer",
            CodeRelationshipKind.Defines);
        HasRelationshipBetween(
            result,
            "csharp:decl:csharp:type:Sample.Customer:Customer.Validation.cs:3:1",
            "csharp:type:Sample.Customer",
            CodeRelationshipKind.Defines);
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static async Task TestCSharpParserDesignTimeEditorConfiguration()
{
    var root = Directory.CreateTempSubdirectory("codemesh-editor-config-test-").FullName;
    var hook = Path.Combine(AppContext.BaseDirectory, "CodeMesh.DesignTime.targets");
    if (!File.Exists(hook))
    {
        throw new InvalidOperationException("The design-time hook must be included in parser output.");
    }

    try
    {
        async Task<ParseResult> ParseFixture(string label, bool fail)
        {
            var projectRoot = Path.Combine(root, label);
            Directory.CreateDirectory(projectRoot);
            var audit = Path.Combine(root, $"{label}.audit");
            var escapedHook = System.Security.SecurityElement.Escape(hook);
            var escapedAudit = System.Security.SecurityElement.Escape(audit);
            await File.WriteAllTextAsync(Path.Combine(projectRoot, "Same.csproj"), $$"""
                <Project Sdk="Microsoft.NET.Sdk">
                  <PropertyGroup>
                    <TargetFramework>net10.0</TargetFramework>
                    <RootNamespace>{{label}}</RootNamespace>
                    <CodeMeshFixtureProperty>{{label}}</CodeMeshFixtureProperty>
                  </PropertyGroup>
                  <ItemGroup>
                    <CompilerVisibleProperty Include="CodeMeshFixtureProperty" />
                  </ItemGroup>
                  <Import Project="{{escapedHook}}" />
                  <Target Name="RecordConfiguration" AfterTargets="GenerateMSBuildEditorConfigFileCore">
                    <PropertyGroup>
                      <CapturedConfiguration>$([System.IO.File]::ReadAllText('$(GeneratedMSBuildEditorConfigFile)'))</CapturedConfiguration>
                    </PropertyGroup>
                    <WriteLinesToFile File="{{escapedAudit}}" Lines="$(GeneratedMSBuildEditorConfigFile);$(CapturedConfiguration)" Overwrite="true" />
                    <Error Condition="'{{fail}}' == 'True'" Text="Intentional design-time fixture failure" />
                  </Target>
                </Project>
                """);
            await File.WriteAllTextAsync(Path.Combine(projectRoot, "Wanted.cs"),
                $"namespace {label}; public sealed class Wanted {{ public int Value => 42; }}");
            return await new CSharpParseService().ParseAsync(new ParseRequest(
                projectRoot, null, null, "csharp", new Dictionary<string, string>()));
        }

        var results = await Task.WhenAll(ParseFixture("First", false), ParseFixture("Second", false));
        foreach (var result in results)
        {
            HasNode(result, CodeNodeKind.Class, "Wanted");
            if (result.Diagnostics.Any(item => item.Code is "CMSHARP010" or "CMSHARP012"))
            {
                throw new InvalidOperationException("Editor-config fixtures must load with MSBuild.");
            }
        }

        var failed = await ParseFixture("Failed", true);
        if (!failed.Diagnostics.Any(item => item.Message.Contains("Intentional design-time fixture failure", StringComparison.Ordinal)))
        {
            throw new InvalidOperationException("The deliberate project-load failure must remain visible.");
        }

        var generatedPaths = new List<string>();
        foreach (var label in new[] { "First", "Second", "Failed" })
        {
            var lines = await File.ReadAllLinesAsync(Path.Combine(root, $"{label}.audit"));
            var generated = lines[0];
            generatedPaths.Add(generated);
            if (!lines.Any(line => line.Trim() == $"build_property.CodeMeshFixtureProperty = {label}"))
            {
                throw new InvalidOperationException($"Compiler-visible metadata was not preserved for {label}.");
            }

            if (Path.GetRelativePath(root, generated).Split(Path.DirectorySeparatorChar)[0] != "..")
            {
                throw new InvalidOperationException("Generated configuration must be outside the repository.");
            }

            if (File.Exists(generated) || Directory.Exists(Path.GetDirectoryName(generated)))
            {
                throw new InvalidOperationException("Request-owned configuration must be removed after workspace disposal.");
            }

            if (Directory.EnumerateFiles(Path.Combine(root, label), "*.editorconfig", SearchOption.AllDirectories).Any())
            {
                throw new InvalidOperationException("The hook must not write editor configuration inside the repository.");
            }
        }

        Equal(3, generatedPaths.Distinct(StringComparer.Ordinal).Count(), "Concurrent project output paths collided.");
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static async Task TestCSharpParserHonorsProjectCompileItems()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-parser-project-test-{Guid.NewGuid():N}");
    Directory.CreateDirectory(root);

    try
    {
        var projectPath = Path.Combine(root, "ProjectLoading.csproj");
        await File.WriteAllTextAsync(
            projectPath,
            """
            <Project Sdk="Microsoft.NET.Sdk">
              <PropertyGroup>
                <TargetFramework>net10.0</TargetFramework>
                <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
                <ImplicitUsings>disable</ImplicitUsings>
                <Nullable>enable</Nullable>
              </PropertyGroup>
              <ItemGroup>
                <Compile Include="Included.cs" />
              </ItemGroup>
            </Project>
            """);

        await File.WriteAllTextAsync(
            Path.Combine(root, "Included.cs"),
            """
            namespace Sample;

            public sealed class Included
            {
            }
            """);

        await File.WriteAllTextAsync(
            Path.Combine(root, "Excluded.cs"),
            """
            namespace Sample;

            public sealed class Excluded
            {
            }
            """);

        var parser = new CSharpParseService();
        var result = await parser.ParseAsync(new ParseRequest(
            root,
            null,
            projectPath,
            "csharp",
            new Dictionary<string, string>()));

        var errors = result.Diagnostics
            .Where(diagnostic => string.Equals(diagnostic.Severity, "error", StringComparison.OrdinalIgnoreCase))
            .Select(diagnostic => diagnostic.Message)
            .ToArray();

        if (errors.Length > 0)
        {
            throw new InvalidOperationException($"Parser returned errors: {string.Join("; ", errors)}");
        }

        HasNodeId(result, "csharp:file:Included.cs");
        HasNodeId(result, "csharp:type:Sample.Included");
        HasNoNodeId(result, "csharp:file:Excluded.cs", result);
        HasNoNodeId(result, "csharp:type:Sample.Excluded", result);
    }
    finally
    {
        Directory.Delete(root, recursive: true);
    }
}

static async Task TestCSharpParserAppliesRepositoryPathFilters()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-parser-path-filter-test-{Guid.NewGuid():N}");
    var externalRoot = Path.Combine(Path.GetTempPath(), $"codemesh-parser-path-filter-external-test-{Guid.NewGuid():N}");
    Directory.CreateDirectory(Path.Combine(root, "src", "private"));
    Directory.CreateDirectory(Path.Combine(root, "tests"));
    Directory.CreateDirectory(externalRoot);

    try
    {
        var projectPath = Path.Combine(root, "Filtered.csproj");
        await File.WriteAllTextAsync(
            projectPath,
            "<Project Sdk=\"Microsoft.NET.Sdk\"><PropertyGroup><TargetFramework>net10.0</TargetFramework></PropertyGroup></Project>");
        await File.WriteAllTextAsync(
            Path.Combine(root, "src", "Visible.cs"),
            "namespace Sample; public sealed class Visible { }");
        await File.WriteAllTextAsync(
            Path.Combine(root, "src", "private", "Hidden.cs"),
            "namespace Sample; public sealed class Hidden { }");
        await File.WriteAllTextAsync(
            Path.Combine(root, "tests", "VisibleTests.cs"),
            "namespace Sample.Tests; public sealed class VisibleTests { }");
        var externalProjectPath = Path.Combine(externalRoot, "External.csproj");
        await File.WriteAllTextAsync(
            externalProjectPath,
            "<Project Sdk=\"Microsoft.NET.Sdk\"><PropertyGroup><TargetFramework>net10.0</TargetFramework></PropertyGroup></Project>");

        var result = await new CSharpParseService().ParseAsync(new ParseRequest(
            root,
            null,
            projectPath,
            "csharp",
            new Dictionary<string, string>(),
            new RepositoryPathFilter(
                AllowPatterns: ["src/**"],
                DenyPatterns: ["src/private/**"])));

        Equal(0, result.Diagnostics.Count(diagnostic => diagnostic.Severity == "error"), "C# parser returned errors for a filtered repository.");
        HasNodeId(result, "csharp:file:src/Visible.cs");
        HasNodeId(result, "csharp:type:Sample.Visible");
        HasNoNodeId(result, "csharp:file:src/private/Hidden.cs", result);
        HasNoNodeId(result, "csharp:type:Sample.Hidden", result);
        HasNoNodeId(result, "csharp:file:tests/VisibleTests.cs", result);

        await ThrowsAsync<InvalidOperationException>(
            () => new CSharpParseService().ParseAsync(new ParseRequest(
                root,
                null,
                externalProjectPath,
                "csharp",
                new Dictionary<string, string>())),
            "C# parser opened an explicit project manifest outside the repository path policy.");
    }
    finally
    {
        Directory.Delete(root, recursive: true);
        Directory.Delete(externalRoot, recursive: true);
    }
}

static async Task TestDeploymentParserEmitsDockerfileAndComposeNodes()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-deployment-parser-test-{Guid.NewGuid():N}");

    try
    {
        Directory.CreateDirectory(root);
        Directory.CreateDirectory(Path.Combine(root, "private"));
        await File.WriteAllTextAsync(
            Path.Combine(root, "Dockerfile"),
            """
            FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
            WORKDIR /src
            COPY . .
            RUN dotnet publish -o /app/publish

            FROM mcr.microsoft.com/dotnet/aspnet:10.0
            WORKDIR /app
            COPY --from=build /app/publish ./
            ENV ASPNETCORE_URLS=http://+:8080
            EXPOSE 8080
            ENTRYPOINT ["dotnet", "Sample.dll"]
            """);
        await File.WriteAllTextAsync(
            Path.Combine(root, "docker-compose.yml"),
            """
            services:
              api:
                build:
                  context: .
                  dockerfile: Dockerfile
                ports:
                  - "8080:8080"
                environment:
                  ASPNETCORE_ENVIRONMENT: Development
                depends_on:
                  - db

              db:
                image: postgres:16
                ports:
                  - "5432:5432"
            """);
        await File.WriteAllTextAsync(
            Path.Combine(root, "private", "docker-compose.yml"),
            "services: { hidden: { image: hidden:latest } }");

        var parser = new DeploymentParseService();
        var result = await parser.ParseAsync(new ParseRequest(
            root,
            null,
            null,
            "deployment",
            new Dictionary<string, string>(),
            new RepositoryPathFilter(DenyPatterns: ["private/**"])));

        Equal("codemesh-parser-deployment", result.ParserName, "Deployment parser name changed.");
        Equal("deployment", result.Language, "Deployment parser language changed.");
        Equal(0, result.Diagnostics.Count(diagnostic => diagnostic.Severity == "error"), "Deployment parser returned errors.");

        var nodeIds = result.Nodes.Select(node => node.Id).ToArray();
        Equal(true, nodeIds.Contains("deployment:dockerfile:Dockerfile"), "Deployment parser did not emit Dockerfile node.");
        Equal(true, nodeIds.Contains("deployment:dockerfile-stage:Dockerfile#build"), "Deployment parser did not emit build stage node.");
        Equal(true, nodeIds.Contains("deployment:dockerfile-stage:Dockerfile#stage-2"), "Deployment parser did not emit runtime stage node.");
        Equal(true, nodeIds.Contains("deployment:compose:docker-compose.yml"), "Deployment parser did not emit Compose file node.");
        Equal(true, nodeIds.Contains("deployment:compose-service:docker-compose.yml#api"), "Deployment parser did not emit api service node.");
        Equal(true, nodeIds.Contains("deployment:compose-service:docker-compose.yml#db"), "Deployment parser did not emit db service node.");
        Equal(false, nodeIds.Any(id => id.Contains("private/", StringComparison.Ordinal)), "Deployment parser ignored the configured deny pattern.");

        var runtimeStage = result.Nodes.Single(node => node.Id == "deployment:dockerfile-stage:Dockerfile#stage-2");
        Equal(CodeNodeKind.DockerfileStage, runtimeStage.Kind, "Deployment parser did not use DockerfileStage node kind.");
        Equal("mcr.microsoft.com/dotnet/aspnet:10.0", runtimeStage.Metadata["baseImage"], "Deployment parser did not capture runtime base image.");
        Equal("8080", runtimeStage.Metadata["exposedPorts"], "Deployment parser did not capture exposed ports.");

        var api = result.Nodes.Single(node => node.Id == "deployment:compose-service:docker-compose.yml#api");
        Equal(CodeNodeKind.ComposeService, api.Kind, "Deployment parser did not use ComposeService node kind.");
        Equal(".", api.Metadata["build"], "Deployment parser did not capture build context.");
        Equal("8080:8080", api.Metadata["ports"], "Deployment parser did not capture service ports.");
        Equal("ASPNETCORE_ENVIRONMENT", api.Metadata["environmentKeys"], "Deployment parser did not capture environment keys.");
        Equal("db", api.Metadata["dependsOn"], "Deployment parser did not capture service dependencies.");

        var dependency = result.Relationships.SingleOrDefault(relationship =>
            relationship.SourceNodeId == "deployment:compose-service:docker-compose.yml#api" &&
            relationship.TargetNodeId == "deployment:compose-service:docker-compose.yml#db" &&
            relationship.Label == "depends_on");
        NotNull(dependency, "Deployment parser did not emit Compose service dependency relationship.");
    }
    finally
    {
        if (Directory.Exists(root))
        {
            Directory.Delete(root, recursive: true);
        }
    }
}

static async Task TestDeploymentParserParsesRepositoryRuntimeArtifacts()
{
    var parser = new DeploymentParseService();
    var result = await parser.ParseAsync(new ParseRequest(
        Directory.GetCurrentDirectory(),
        null,
        null,
        "deployment",
        new Dictionary<string, string>()));

    Equal(0, result.Diagnostics.Count(diagnostic => diagnostic.Severity == "error"), "Deployment parser returned errors for repository runtime artifacts.");
    var nodeIds = result.Nodes.Select(node => node.Id).ToArray();
    Equal(true, nodeIds.Contains("deployment:compose:docker-compose.yml"), "Deployment parser did not emit repository Compose file node.");
    Equal(true, nodeIds.Contains("deployment:compose-service:docker-compose.yml#agent-access"), "Deployment parser did not emit agent-access service node.");
    Equal(true, nodeIds.Contains("deployment:compose-service:docker-compose.yml#csharp-parser"), "Deployment parser did not emit csharp-parser service node.");
    Equal(true, nodeIds.Contains("deployment:dockerfile:src/CodeMesh.Parser.CSharp/Dockerfile"), "Deployment parser did not emit C# parser Dockerfile node.");
}

static async Task TestMarkdownParserEmitsDocumentsSectionsAndContainment()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-markdown-parser-test-{Guid.NewGuid():N}");
    try
    {
        Directory.CreateDirectory(root);
        Directory.CreateDirectory(Path.Combine(root, "private"));
        var ignoredDirectories = new[] { ".venv", ".tmp", ".codemesh-smoke" };
        foreach (var ignoredDirectory in ignoredDirectories)
        {
            var ignoredPath = Path.Combine(root, ignoredDirectory);
            Directory.CreateDirectory(ignoredPath);
            await File.WriteAllTextAsync(Path.Combine(ignoredPath, "Generated.md"), "# Generated");
        }

        await File.WriteAllTextAsync(
            Path.Combine(root, "README.md"),
            """
            # Product

            Overview text.

            ## Setup

            Run the thing.

            ### Local

            Use local services.
            """);
        await File.WriteAllTextAsync(
            Path.Combine(root, "private", "Hidden.md"),
            "# Hidden");

        var parser = new MarkdownParseService();
        var result = await parser.ParseAsync(new ParseRequest(
            root,
            null,
            null,
            "markdown",
            new Dictionary<string, string>(),
            new RepositoryPathFilter(DenyPatterns: ["private/**"])));

        Equal("codemesh-parser-markdown", result.ParserName, "Markdown parser name changed.");
        Equal(0, result.Diagnostics.Count(diagnostic => diagnostic.Severity == "error"), "Markdown parser emitted errors.");
        HasNode(result, CodeNodeKind.Document, "README.md");
        HasNode(result, CodeNodeKind.Section, "Product");
        HasNode(result, CodeNodeKind.Section, "Setup");
        HasNode(result, CodeNodeKind.Section, "Local");
        Equal(false, result.Nodes.Any(node => node.Span.FilePath.StartsWith("private/", StringComparison.Ordinal)), "Markdown parser ignored the configured deny pattern.");
        Equal(
            false,
            result.Nodes.Any(node => ignoredDirectories.Any(directory =>
                node.Span.FilePath.StartsWith($"{directory}/", StringComparison.OrdinalIgnoreCase))),
            "Markdown parser indexed generated or temporary documentation.");
        HasRelationshipBetween(
            result,
            "markdown:document:README.md",
            "markdown:section:README.md#product",
            CodeRelationshipKind.Contains);
        HasRelationshipBetween(
            result,
            "markdown:section:README.md#setup",
            "markdown:section:README.md#local",
            CodeRelationshipKind.Contains);

        var setup = result.Nodes.Single(node => node.Id == "markdown:section:README.md#setup");
        Equal("2", setup.Metadata["headingLevel"], "Markdown heading level metadata changed.");
    }
    finally
    {
        if (Directory.Exists(root))
        {
            Directory.Delete(root, recursive: true);
        }
    }
}

static async Task TestMarkdownParserParsesRepositoryDocs()
{
    var root = Directory.GetCurrentDirectory();
    var parser = new MarkdownParseService();
    var result = await parser.ParseAsync(new ParseRequest(
        root,
        null,
        null,
        "markdown",
        new Dictionary<string, string>()));

    Equal(0, result.Diagnostics.Count(diagnostic => diagnostic.Severity == "error"), "Markdown parser emitted errors for repository docs.");
    HasNode(result, CodeNodeKind.Document, "README.md");
    HasNode(result, CodeNodeKind.Section, "CodeMesh");
    HasNode(result, CodeNodeKind.Document, "next-steps.md");
    HasNode(result, CodeNodeKind.Section, "Current Execution Order");
}

static async Task TestPythonParserEmitsClassesFunctionsAndContainment()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-python-parser-test-{Guid.NewGuid():N}");
    try
    {
        Directory.CreateDirectory(root);
        await File.WriteAllTextAsync(
            Path.Combine(root, "service.py"),
            """
            import asyncio

            class Greeter:
                def greet(self, name: str) -> str:
                    return normalize(name)

            class GreeterContract:
                def configure(self, *, enabled: bool) -> None: ...

            class GreeterAdapter:
                def configure(self, *, enabled: bool) -> None:
                    return None

            async def normalize(value: str) -> str:
                return value.strip().lower()

            def format_name(
                value: str,
            ) -> str:
                return normalize(value)
            """);

        var parser = new PythonParseService();
        var result = await parser.ParseAsync(new ParseRequest(
            root,
            null,
            null,
            "python",
            new Dictionary<string, string>()));

        Equal("codemesh-parser-python", result.ParserName, "Python parser name changed.");
        Equal(0, result.Diagnostics.Count(diagnostic => diagnostic.Severity == "error"), "Python parser emitted errors.");
        HasNode(result, CodeNodeKind.File, "service.py");
        HasNode(result, CodeNodeKind.Class, "Greeter");
        HasNode(result, CodeNodeKind.Method, "greet");
        HasNode(result, CodeNodeKind.Method, "normalize");
        HasNode(result, CodeNodeKind.Method, "format_name");
        Equal(
            2,
            result.Nodes.Count(node => node.Kind == CodeNodeKind.Method && node.Name == "configure"),
            "Python parser did not keep same-named methods in distinct inline-body classes.");
        HasRelationshipBetween(
            result,
            "python:file:service.py",
            "python:class:service.Greeter",
            CodeRelationshipKind.Contains);
        HasRelationshipBetween(
            result,
            "python:class:service.Greeter",
            "python:method:service.Greeter.greet",
            CodeRelationshipKind.Contains);

        var normalize = result.Nodes.Single(node => node.Id == "python:method:service.normalize");
        Equal("True", normalize.Metadata["async"], "Python parser did not mark async functions.");
        HasRelationshipBetween(
            result,
            "python:method:service.format_name",
            normalize.Id,
            CodeRelationshipKind.Invokes);
    }
    finally
    {
        if (Directory.Exists(root))
        {
            Directory.Delete(root, recursive: true);
        }
    }
}

static async Task TestPythonParserParsesAgentAccessProject()
{
    var root = Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), "agent-access"));
    if (!Directory.Exists(root))
    {
        throw new SkipTestException($"Agent Access root not found: {root}");
    }

    var parser = new PythonParseService();
    var result = await parser.ParseAsync(new ParseRequest(
        root,
        null,
        null,
        "python",
        new Dictionary<string, string>()));

    Equal(0, result.Diagnostics.Count(diagnostic => diagnostic.Severity == "error"), "Python parser emitted errors for Agent Access.");
    if (result.Nodes.Count(node => node.Kind == CodeNodeKind.File) < 10)
    {
        throw new InvalidOperationException("Python parser emitted too few Agent Access file nodes.");
    }

    HasNode(result, CodeNodeKind.Class, "CodeMeshReadStore");
    HasNode(result, CodeNodeKind.Method, "search_context");
    HasNode(result, CodeNodeKind.Method, "tool_manifest");
}

static async Task TestPythonParserEmitsImportsCallsAndTestCases()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-python-semantic-test-{Guid.NewGuid():N}");
    try
    {
        Directory.CreateDirectory(root);
        await File.WriteAllTextAsync(
            Path.Combine(root, "native.py"),
            """
            from _onenine_feed_hub_native import replay as native_replay
            from _onenine_feed_hub_native import replay as native_replay

            def run_replay():
                return native_replay()

            def test_run_replay():
                return run_replay()
            """);

        var result = await new PythonParseService().ParseAsync(new ParseRequest(
            root,
            null,
            null,
            "python",
            new Dictionary<string, string>()));

        var import = result.Nodes.Single(node =>
            node.Metadata.TryGetValue("pythonKind", out var kind) && kind == "import");
        var run = result.Nodes.Single(node => node.Name == "run_replay");
        var test = result.Nodes.Single(node => node.Name == "test_run_replay");
        Equal("_onenine_feed_hub_native", import.Metadata["importModule"], "Python import module metadata changed.");
        Equal("replay", import.Metadata["importedName"], "Python imported-name metadata changed.");
        Equal(CodeNodeKind.TestCase, test.Kind, "Python test function was not emitted as a test case.");
        HasRelationshipBetween(result, run.Id, import.Id, CodeRelationshipKind.Invokes);
        HasRelationshipBetween(result, test.Id, run.Id, CodeRelationshipKind.Invokes);
    }
    finally
    {
        if (Directory.Exists(root))
        {
            Directory.Delete(root, recursive: true);
        }
    }
}

static async Task TestRustParserEmitsDeclarationsRelationshipsTestsAndPyO3Exports()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-rust-parser-test-{Guid.NewGuid():N}");
    try
    {
        Directory.CreateDirectory(Path.Combine(root, "src"));
        Directory.CreateDirectory(Path.Combine(root, "target", "debug"));
        await File.WriteAllTextAsync(
            Path.Combine(root, "src", "lib.rs"),
            """
            use pyo3::prelude::*;

            trait Runner {
                fn run(&self);
            }

            #[pyclass]
            struct Replay;

            impl Runner for Replay {
                fn run(&self) {
                    helper();
                }
            }

            fn helper() {}

            #[pyfunction]
            #[pyo3(name = "replay")]
            fn replay_impl(value: Replay) -> Replay {
                helper();
                value
            }

            #[pymodule]
            fn _onenine_feed_hub_native() {}

            #[test]
            fn test_replay() {
                replay_impl(Replay);
            }
            """);
        await File.WriteAllTextAsync(
            Path.Combine(root, "target", "debug", "generated.rs"),
            "fn must_not_be_indexed() {}\n");

        var result = await new RustParseService().ParseAsync(new ParseRequest(
            root,
            null,
            null,
            "rust",
            new Dictionary<string, string>()));
        var repeatedResult = await new RustParseService().ParseAsync(new ParseRequest(
            root,
            null,
            null,
            "rust",
            new Dictionary<string, string>()));

        Equal("codemesh-parser-rust", result.ParserName, "Rust parser name changed.");
        Equal(0, result.Diagnostics.Count(item => item.Severity == "error"), "Rust parser emitted errors.");
        Equal(
            string.Join('\n', result.Nodes.Select(node => node.Id).Order(StringComparer.Ordinal)),
            string.Join('\n', repeatedResult.Nodes.Select(node => node.Id).Order(StringComparer.Ordinal)),
            "Rust node identities were not deterministic.");
        Equal(
            string.Join('\n', result.Relationships.Select(relationship => relationship.Id).Order(StringComparer.Ordinal)),
            string.Join('\n', repeatedResult.Relationships.Select(relationship => relationship.Id).Order(StringComparer.Ordinal)),
            "Rust relationship identities were not deterministic.");
        HasNode(result, CodeNodeKind.Interface, "Runner");
        HasNode(result, CodeNodeKind.Struct, "Replay");
        HasNode(result, CodeNodeKind.Method, "helper");
        HasNode(result, CodeNodeKind.TestCase, "test_replay");
        Equal(false, result.Nodes.Any(node => node.Name == "must_not_be_indexed"), "Rust parser indexed Cargo target output.");

        var implementation = result.Nodes.Single(node =>
            node.Metadata.TryGetValue("rustKind", out var kind) && kind == "impl");
        var traitNode = result.Nodes.Single(node => node.Name == "Runner" && node.Kind == CodeNodeKind.Interface);
        HasRelationshipBetween(result, implementation.Id, traitNode.Id, CodeRelationshipKind.Implements);

        var replay = result.Nodes.Single(node =>
            node.Metadata.TryGetValue("pythonExportName", out var name) && name == "replay");
        Equal("function", replay.Metadata["pythonExportKind"], "Rust PyO3 function export metadata changed.");
        var module = result.Nodes.Single(node =>
            node.Metadata.TryGetValue("pythonExportKind", out var kind) && kind == "module");
        Equal("_onenine_feed_hub_native", module.Metadata["pythonExportName"], "Rust PyO3 module name changed.");
        HasRelationship(result, CodeRelationshipKind.Invokes);
        HasRelationship(result, CodeRelationshipKind.UsesType);
    }
    finally
    {
        if (Directory.Exists(root))
        {
            Directory.Delete(root, recursive: true);
        }
    }
}

static async Task TestCompositeParserLinksPythonCallsToRustPyO3Exports()
{
    var root = Path.Combine(Path.GetTempPath(), $"codemesh-pyo3-boundary-test-{Guid.NewGuid():N}");
    try
    {
        Directory.CreateDirectory(Path.Combine(root, "src"));
        Directory.CreateDirectory(Path.Combine(root, "ignored"));
        await File.WriteAllTextAsync(
            Path.Combine(root, "bridge.py"),
            """
            from _onenine_feed_hub_native import replay

            def run():
                replay()
                return replay()
            """);
        await File.WriteAllTextAsync(
            Path.Combine(root, "src", "lib.rs"),
            """
            #[pyfunction]
            fn replay() {}

            #[pymodule]
            fn _onenine_feed_hub_native() {}
            """);
        await File.WriteAllTextAsync(
            Path.Combine(root, "ignored", "skip.py"),
            "def must_not_be_indexed(): pass\n");
        await File.WriteAllTextAsync(
            Path.Combine(root, "ignored", "skip.rs"),
            "fn must_not_be_indexed() {}\n");

        var parser = new CompositeParserClient(new Dictionary<string, IParserClient>
        {
            ["python"] = new LocalPythonFixtureClient(),
            ["rust"] = new LocalRustFixtureClient()
        });
        var result = await parser.ParseAsync(new ParseRequest(
            root,
            null,
            null,
            "python,rust",
            new Dictionary<string, string>(),
            new RepositoryPathFilter(DenyPatterns: ["ignored/**"])));

        var pythonRun = result.Nodes.Single(node => node.Language == "python" && node.Name == "run");
        var rustReplay = result.Nodes.Single(node =>
            node.Language == "rust" &&
            node.Metadata.TryGetValue("pythonExportName", out var name) &&
            name == "replay");
        var boundary = result.Relationships.SingleOrDefault(relationship =>
            relationship.SourceNodeId == pythonRun.Id &&
            relationship.TargetNodeId == rustReplay.Id &&
            relationship.Kind == CodeRelationshipKind.Invokes &&
            relationship.Metadata.TryGetValue("boundary", out var value) &&
            value == "pyo3");
        NotNull(boundary, "Composite parser did not link Python invocation to Rust PyO3 export.");
        Equal(false, result.Nodes.Any(node => node.Name == "must_not_be_indexed"), "Composite parser did not apply the shared deny pattern.");
        Equal(
            1,
            result.Relationships.Count(relationship =>
                relationship.SourceNodeId == pythonRun.Id &&
                relationship.TargetNodeId == rustReplay.Id &&
                relationship.Kind == CodeRelationshipKind.Invokes),
            "Composite parser did not coalesce repeated calls across the PyO3 boundary.");
    }
    finally
    {
        if (Directory.Exists(root))
        {
            Directory.Delete(root, recursive: true);
        }
    }
}

static async Task TestYoutubeDownloaderSampleParser()
{
    var sampleRoot = Environment.GetEnvironmentVariable("CODEMESH_SAMPLE_CSHARP_ROOT");
    if (string.IsNullOrWhiteSpace(sampleRoot))
    {
        throw new SkipTestException(
            "CODEMESH_SAMPLE_CSHARP_ROOT is not configured; synthetic parser tests still run.");
    }

    var solutionPath = Environment.GetEnvironmentVariable("CODEMESH_SAMPLE_CSHARP_SOLUTION");
    if (string.IsNullOrWhiteSpace(solutionPath))
    {
        solutionPath = Path.Combine(sampleRoot, "YoutubeDownloader.slnx");
    }

    if (!Directory.Exists(sampleRoot))
    {
        throw new SkipTestException($"Sample root not found: {sampleRoot}");
    }

    var parser = new CSharpParseService();
    var result = await parser.ParseAsync(new ParseRequest(
        sampleRoot,
        File.Exists(solutionPath) ? solutionPath : null,
        null,
        "csharp",
        new Dictionary<string, string>()));

    var errors = result.Diagnostics
        .Where(diagnostic => string.Equals(diagnostic.Severity, "error", StringComparison.OrdinalIgnoreCase))
        .Select(diagnostic => diagnostic.Message)
        .ToArray();

    if (errors.Length > 0)
    {
        throw new InvalidOperationException($"Parser returned errors: {string.Join("; ", errors)}");
    }

    if (result.Nodes.Count == 0)
    {
        throw new InvalidOperationException("Parser returned no nodes for the YoutubeDownloader sample.");
    }

    Equal(result.Nodes.Count, result.Contents.Count, "File-level parser should emit one content item per node.");

    var hasExpectedFile = result.Nodes.Any(node =>
        string.Equals(
            node.Span.FilePath.Replace('\\', '/'),
            "YoutubeDownloader.Core/Downloading/VideoDownloader.cs",
            StringComparison.OrdinalIgnoreCase));

    if (!hasExpectedFile)
    {
        throw new InvalidOperationException("Parser did not include the expected VideoDownloader.cs sample file.");
    }
}

static string RunGit(string workingDirectory, params string[] arguments)
{
    var startInfo = new ProcessStartInfo
    {
        FileName = "git",
        WorkingDirectory = workingDirectory,
        RedirectStandardOutput = true,
        RedirectStandardError = true,
        UseShellExecute = false,
        CreateNoWindow = true
    };
    foreach (var argument in arguments)
    {
        startInfo.ArgumentList.Add(argument);
    }

    using var process = Process.Start(startInfo)
        ?? throw new InvalidOperationException("Could not start Git for test setup.");
    var standardOutput = process.StandardOutput.ReadToEnd();
    var standardError = process.StandardError.ReadToEnd();
    process.WaitForExit();
    if (process.ExitCode != 0)
    {
        throw new InvalidOperationException($"Git test setup failed: {standardError.Trim()}");
    }

    return standardOutput.Trim();
}

static void CopyDirectory(string source, string destination)
{
    Directory.CreateDirectory(destination);
    foreach (var directory in Directory.EnumerateDirectories(source, "*", SearchOption.AllDirectories))
    {
        Directory.CreateDirectory(Path.Combine(destination, Path.GetRelativePath(source, directory)));
    }

    foreach (var file in Directory.EnumerateFiles(source, "*", SearchOption.AllDirectories))
    {
        var target = Path.Combine(destination, Path.GetRelativePath(source, file));
        Directory.CreateDirectory(Path.GetDirectoryName(target) ?? destination);
        File.Copy(file, target, overwrite: true);
    }
}

static void HasNode(ParseResult result, CodeNodeKind kind, string name)
{
    if (!result.Nodes.Any(node => node.Kind == kind && string.Equals(node.Name, name, StringComparison.Ordinal)))
    {
        throw new InvalidOperationException($"Expected parser to emit {kind} node named {name}.");
    }
}

static void HasNodeId(ParseResult result, string nodeId)
{
    if (!result.Nodes.Any(node => string.Equals(node.Id, nodeId, StringComparison.Ordinal)))
    {
        throw new InvalidOperationException($"Expected parser to emit node id {nodeId}.");
    }
}

static void HasNoNodeId(ParseResult result, string nodeId, ParseResult? diagnosticSource = null)
{
    if (result.Nodes.Any(node => string.Equals(node.Id, nodeId, StringComparison.Ordinal)))
    {
        var diagnostics = diagnosticSource is null
            ? string.Empty
            : $" Diagnostics: {string.Join(" | ", diagnosticSource.Diagnostics.Select(diagnostic => $"{diagnostic.Code}:{diagnostic.Severity}:{diagnostic.Message}"))}";
        throw new InvalidOperationException($"Expected parser not to emit node id {nodeId}.{diagnostics}");
    }
}

static void HasRelationship(ParseResult result, CodeRelationshipKind kind)
{
    if (!result.Relationships.Any(relationship => relationship.Kind == kind))
    {
        throw new InvalidOperationException($"Expected parser to emit {kind} relationship.");
    }
}

static void HasRelationshipBetween(ParseResult result, string sourceNodeId, string targetNodeId, CodeRelationshipKind kind)
{
    if (!result.Relationships.Any(relationship =>
        relationship.Kind == kind &&
        string.Equals(relationship.SourceNodeId, sourceNodeId, StringComparison.Ordinal) &&
        string.Equals(relationship.TargetNodeId, targetNodeId, StringComparison.Ordinal)))
    {
        throw new InvalidOperationException($"Expected parser to emit {kind} relationship from {sourceNodeId} to {targetNodeId}.");
    }
}

static void Equal<T>(T expected, T actual, string message)
{
    if (!EqualityComparer<T>.Default.Equals(expected, actual))
    {
        throw new InvalidOperationException($"{message} Expected {expected}, got {actual}.");
    }
}

static void NotNull<T>(T? value, string message)
{
    if (value is null)
    {
        throw new InvalidOperationException(message);
    }
}

static void IsNull<T>(T? value, string message)
{
    if (value is not null)
    {
        throw new InvalidOperationException(message);
    }
}

static void Throws<TException>(Action action, string message)
    where TException : Exception
{
    try
    {
        action();
    }
    catch (TException)
    {
        return;
    }
    catch (Exception exception)
    {
        throw new InvalidOperationException($"{message} Expected {typeof(TException).Name}, got {exception.GetType().Name}.");
    }

    throw new InvalidOperationException($"{message} Expected {typeof(TException).Name}, but no exception was thrown.");
}

static async Task ThrowsAsync<TException>(Func<Task> action, string message)
    where TException : Exception
{
    try
    {
        await action().ConfigureAwait(false);
    }
    catch (TException)
    {
        return;
    }
    catch (Exception exception)
    {
        throw new InvalidOperationException($"{message} Expected {typeof(TException).Name}, got {exception.GetType().Name}.");
    }

    throw new InvalidOperationException($"{message} Expected {typeof(TException).Name}, but no exception was thrown.");
}

static CodeNode SummaryNode(
    CodeNodeKind kind,
    string name,
    string text,
    int startLine,
    int endLine)
{
    var hash = CodeMeshHash.Sha256Hex(text);
    return new CodeNode(
        $"summary-test:{kind}:{name}:{hash}",
        $"summary-test:{kind}:{name}",
        kind,
        name,
        "csharp",
        "CodeMesh.Tests",
        new SourceSpan($"{name}.cs", startLine, 1, endLine, 1),
        hash,
        new Dictionary<string, string>());
}

static CodeContent SummaryContent(string text)
{
    var hash = CodeMeshHash.Sha256Hex(text);
    return new CodeContent(
        hash,
        text,
        "text/x-csharp-fragment",
        DateTimeOffset.UtcNow,
        DateTimeOffset.UtcNow);
}

static async Task DeleteQdrantCollectionAsync(string url, string collection)
{
    try
    {
        var baseAddress = url.EndsWith("/", StringComparison.Ordinal) ? url : $"{url}/";
        using var client = new HttpClient
        {
            BaseAddress = new Uri(baseAddress, UriKind.Absolute),
            Timeout = TimeSpan.FromSeconds(2)
        };

        using var response = await client.DeleteAsync($"collections/{Uri.EscapeDataString(collection)}");
    }
    catch (Exception exception) when (exception is HttpRequestException or TaskCanceledException)
    {
    }
}

sealed class SkipTestException(string message) : Exception(message);

sealed class SlowHttpServer : IAsyncDisposable
{
    private readonly TcpListener _listener;
    private readonly CancellationTokenSource _cancellation = new();
    private readonly Task _serverTask;
    private readonly TimeSpan _delay;
    private readonly string _responseBody;
    private int _failuresBeforeSuccess;
    private int _requestCount;

    public SlowHttpServer(
        TimeSpan delay,
        int failuresBeforeSuccess = 0,
        string responseBody = """{"models":[{"name":"test-embed"}]}""")
    {
        _delay = delay;
        _failuresBeforeSuccess = failuresBeforeSuccess;
        _responseBody = responseBody;
        _listener = new TcpListener(IPAddress.Loopback, 0);
        _listener.Start();

        var endpoint = (IPEndPoint)_listener.LocalEndpoint;
        BaseUrl = $"http://127.0.0.1:{endpoint.Port}";
        _serverTask = Task.Run(ServeAsync);
    }

    public string BaseUrl { get; }
    public int RequestCount => Volatile.Read(ref _requestCount);

    public async ValueTask DisposeAsync()
    {
        await _cancellation.CancelAsync();
        _listener.Stop();

        try
        {
            await _serverTask;
        }
        catch (OperationCanceledException)
        {
        }
        catch (SocketException)
        {
        }

        _cancellation.Dispose();
    }

    private async Task ServeAsync()
    {
        while (!_cancellation.IsCancellationRequested)
        {
            using var client = await _listener
                .AcceptTcpClientAsync(_cancellation.Token)
                .ConfigureAwait(false);

            await HandleClientAsync(client, _cancellation.Token)
                .ConfigureAwait(false);
        }
    }

    private async Task HandleClientAsync(TcpClient client, CancellationToken cancellationToken)
    {
        await using var stream = client.GetStream();
        var buffer = new byte[1024];

        while (!cancellationToken.IsCancellationRequested)
        {
            var bytesRead = await stream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
            if (bytesRead == 0)
            {
                return;
            }

            var request = Encoding.ASCII.GetString(buffer, 0, bytesRead);
            if (request.Contains("\r\n\r\n", StringComparison.Ordinal))
            {
                break;
            }
        }

        Interlocked.Increment(ref _requestCount);
        if (Interlocked.CompareExchange(ref _failuresBeforeSuccess, 0, 0) > 0)
        {
            Interlocked.Decrement(ref _failuresBeforeSuccess);
            return;
        }

        await Task.Delay(_delay, cancellationToken).ConfigureAwait(false);

        var response = Encoding.ASCII.GetBytes(
            $"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {_responseBody.Length}\r\nConnection: close\r\n\r\n{_responseBody}");
        await stream.WriteAsync(response, cancellationToken).ConfigureAwait(false);
    }
}

sealed class FailingGraphStore : IGraphStore
{
    public Task UpsertGraphAsync(CodeGraphBatch batch, CancellationToken cancellationToken = default)
    {
        throw new InvalidOperationException("Synthetic graph-store failure.");
    }

    public Task<CodeNode?> GetNodeAsync(string nodeId, CancellationToken cancellationToken = default)
    {
        return Task.FromResult<CodeNode?>(null);
    }

    public Task<IReadOnlyList<CodeRelationship>> GetRelationshipsAsync(
        string nodeId,
        int depth = 1,
        CancellationToken cancellationToken = default)
    {
        return Task.FromResult<IReadOnlyList<CodeRelationship>>(Array.Empty<CodeRelationship>());
    }
}

sealed class FakeParserClient : IParserClient
{
    private const string Text = "public sealed class Demo { }";
    public static readonly string ContentHash = CodeMeshHash.Sha256Hex(Text);
    public static readonly string NodeId = CodeMeshHash.StableId("fake", "Demo.cs", ContentHash);

    public Task<ParserCapability> GetCapabilityAsync(CancellationToken cancellationToken = default)
    {
        return Task.FromResult(new ParserCapability(
            "fake-parser",
            "csharp",
            "test",
            [".cs"],
            ["repositoryRoot"]));
    }

    public Task<ParseResult> ParseAsync(ParseRequest request, CancellationToken cancellationToken = default)
    {
        var now = DateTimeOffset.UtcNow;
        var node = new CodeNode(
            NodeId,
            "Demo:Demo.cs",
            CodeNodeKind.File,
            "Demo.cs",
            "csharp",
            "Demo",
            new SourceSpan("Demo.cs", 1, 1, 1, 1),
            ContentHash,
            new Dictionary<string, string>());

        var content = new CodeContent(
            ContentHash,
            Text,
            "text/x-csharp",
            now,
            now);

        return Task.FromResult(new ParseResult(
            "fake-parser",
            "csharp",
            [node],
            Array.Empty<CodeRelationship>(),
            [content],
            Array.Empty<ParserDiagnostic>(),
            now));
    }
}

sealed class LanguageFixtureParserClient(string language, string extension) : IParserClient
{
    public Task<ParserCapability> GetCapabilityAsync(CancellationToken cancellationToken = default)
    {
        return Task.FromResult(new ParserCapability(
            $"fixture-{language}",
            language,
            "test",
            [extension],
            ["repositoryRoot"]));
    }

    public Task<ParseResult> ParseAsync(
        ParseRequest request,
        CancellationToken cancellationToken = default)
    {
        if (!string.Equals(language, request.Language, StringComparison.Ordinal))
        {
            throw new InvalidOperationException(
                "Composite parser did not isolate the language request.");
        }
        var now = DateTimeOffset.UtcNow;
        var filePath = $"sample{extension}";
        var text = $"{language} fixture";
        var contentHash = CodeMeshHash.Sha256Hex(text);
        var node = new CodeNode(
            $"{language}:file:{filePath}",
            $"{language}:file:{filePath}",
            CodeNodeKind.File,
            filePath,
            language,
            null,
            new SourceSpan(filePath, 1, 1, 1, text.Length),
            contentHash,
            new Dictionary<string, string>());
        var content = new CodeContent(
            contentHash,
            text,
            "text/plain",
            now,
            now);
        return Task.FromResult(new ParseResult(
            $"fixture-{language}",
            language,
            [node],
            Array.Empty<CodeRelationship>(),
            [content],
            Array.Empty<ParserDiagnostic>(),
            now));
    }
}

sealed class LocalPythonFixtureClient : IParserClient
{
    private readonly PythonParseService _parser = new();

    public Task<ParserCapability> GetCapabilityAsync(CancellationToken cancellationToken = default)
    {
        return Task.FromResult(PythonParseService.Capability);
    }

    public Task<ParseResult> ParseAsync(
        ParseRequest request,
        CancellationToken cancellationToken = default)
    {
        return _parser.ParseAsync(request, cancellationToken);
    }
}

sealed class LocalRustFixtureClient : IParserClient
{
    private readonly RustParseService _parser = new();

    public Task<ParserCapability> GetCapabilityAsync(CancellationToken cancellationToken = default)
    {
        return Task.FromResult(RustParseService.Capability);
    }

    public Task<ParseResult> ParseAsync(
        ParseRequest request,
        CancellationToken cancellationToken = default)
    {
        return _parser.ParseAsync(request, cancellationToken);
    }
}

sealed class SecretParserClient : IParserClient
{
    public const string SecretValue = "super-secret-value";
    public static readonly string Text = $$"""
        public static class SecretFixture
        {
            private const string ApiKey = "{{SecretValue}}";
        }
        """;
    public static readonly string ContentHash = CodeMeshHash.Sha256Hex(Text);
    public const string NodeId = "csharp:type:SecretFixture";

    public Task<ParserCapability> GetCapabilityAsync(CancellationToken cancellationToken = default)
    {
        return Task.FromResult(new ParserCapability(
            "secret-parser",
            "csharp",
            "test",
            [".cs"],
            ["repositoryRoot"]));
    }

    public Task<ParseResult> ParseAsync(ParseRequest request, CancellationToken cancellationToken = default)
    {
        var now = DateTimeOffset.UtcNow;
        var node = new CodeNode(
            NodeId,
            NodeId,
            CodeNodeKind.Class,
            "SecretFixture",
            "csharp",
            "SecretFixture",
            new SourceSpan("SecretFixture.cs", 1, 1, 4, 1),
            ContentHash,
            new Dictionary<string, string>());
        var content = new CodeContent(
            ContentHash,
            Text,
            "text/x-csharp",
            now,
            now);

        return Task.FromResult(new ParseResult(
            "secret-parser",
            "csharp",
            [node],
            Array.Empty<CodeRelationship>(),
            [content],
            Array.Empty<ParserDiagnostic>(),
            now));
    }
}

sealed class RefreshParserClient(string typeName) : IParserClient
{
    public string TypeName { get; set; } = typeName;

    public static string NodeIdFor(string typeName) => $"csharp:type:Sample.{typeName}";

    public static string ContentHashFor(string typeName) => CodeMeshHash.Sha256Hex(TextFor(typeName));

    public Task<ParserCapability> GetCapabilityAsync(CancellationToken cancellationToken = default)
    {
        return Task.FromResult(new ParserCapability(
            "refresh-parser",
            "csharp",
            "test",
            [".cs"],
            ["repositoryRoot"]));
    }

    public Task<ParseResult> ParseAsync(ParseRequest request, CancellationToken cancellationToken = default)
    {
        var now = DateTimeOffset.UtcNow;
        var text = TextFor(TypeName);
        var hash = CodeMeshHash.Sha256Hex(text);
        var node = new CodeNode(
            NodeIdFor(TypeName),
            NodeIdFor(TypeName),
            CodeNodeKind.Class,
            TypeName,
            "csharp",
            "Sample",
            new SourceSpan($"{TypeName}.cs", 1, 1, 1, text.Length),
            hash,
            new Dictionary<string, string>());
        var content = new CodeContent(
            hash,
            text,
            "text/x-csharp-fragment",
            now,
            now);

        return Task.FromResult(new ParseResult(
            "refresh-parser",
            "csharp",
            [node],
            Array.Empty<CodeRelationship>(),
            [content],
            Array.Empty<ParserDiagnostic>(),
            now));
    }

    private static string TextFor(string typeName) => $"namespace Sample; public sealed class {typeName} {{ }}";
}

sealed class DeterministicEmbeddingProvider : IEmbeddingProvider
{
    public string Provider => "test";

    public string Model => "deterministic";

    public Task<IReadOnlyList<EmbeddingRecord>> EmbedAsync(
        IReadOnlyList<CodeNode> nodes,
        IReadOnlyDictionary<string, CodeContent> contentByHash,
        CancellationToken cancellationToken = default)
    {
        IReadOnlyList<EmbeddingRecord> embeddings = nodes
            .Select(node => new EmbeddingRecord(
                CodeMeshHash.StableId("embedding", node.Id, node.ContentHash),
                node.Id,
                node.ContentHash,
                Provider,
                Model,
                2,
                [1.0f, 0.0f],
                new Dictionary<string, string>
                {
                    ["preview"] = node.Name
                }))
            .ToArray();

        return Task.FromResult(embeddings);
    }
}

sealed class CapturingEmbeddingProvider : IEmbeddingProvider
{
    public string Provider => "test";

    public string Model => "capturing";

    public string LastText { get; private set; } = string.Empty;

    public Task<IReadOnlyList<EmbeddingRecord>> EmbedAsync(
        IReadOnlyList<CodeNode> nodes,
        IReadOnlyDictionary<string, CodeContent> contentByHash,
        CancellationToken cancellationToken = default)
    {
        var embeddings = new List<EmbeddingRecord>();
        foreach (var node in nodes)
        {
            LastText = contentByHash.TryGetValue(node.ContentHash, out var content)
                ? content.Text
                : string.Empty;
            embeddings.Add(new EmbeddingRecord(
                CodeMeshHash.StableId("embedding", node.Id, node.ContentHash),
                node.Id,
                node.ContentHash,
                Provider,
                Model,
                1,
                [1.0f],
                new Dictionary<string, string>()));
        }

        return Task.FromResult<IReadOnlyList<EmbeddingRecord>>(embeddings);
    }
}

sealed class CountingEmbeddingProvider : IEmbeddingProvider
{
    public int EmbeddedNodeCount { get; private set; }

    public string Provider => "test";

    public string Model => "counting";

    public Task<IReadOnlyList<EmbeddingRecord>> EmbedAsync(
        IReadOnlyList<CodeNode> nodes,
        IReadOnlyDictionary<string, CodeContent> contentByHash,
        CancellationToken cancellationToken = default)
    {
        EmbeddedNodeCount += nodes.Count;

        IReadOnlyList<EmbeddingRecord> embeddings = nodes
            .Select(node => new EmbeddingRecord(
                CodeMeshHash.StableId("embedding", Provider, Model, node.Id, node.ContentHash),
                node.Id,
                node.ContentHash,
                Provider,
                Model,
                2,
                [1.0f, 0.0f],
                new Dictionary<string, string>
                {
                    ["preview"] = node.Name
                }))
            .ToArray();

        return Task.FromResult(embeddings);
    }
}

sealed class CountingSummaryProvider : ICodeSummaryProvider
{
    public CountingSummaryProvider(string generationConfigurationFingerprint = "")
    {
        GenerationConfigurationFingerprint = generationConfigurationFingerprint;
    }

    public int SummarizedNodeCount { get; private set; }

    public CodeSummaryRequest? LastRequest { get; private set; }

    public string Provider => "test";

    public string Model => "summary-counting";

    public string GenerationConfigurationFingerprint { get; }

    public Task<CodeSummaryResult> SummarizeAsync(
        CodeSummaryRequest request,
        CancellationToken cancellationToken = default)
    {
        SummarizedNodeCount++;
        LastRequest = request;
        return Task.FromResult(new CodeSummaryResult(
            $"Summarizes {request.Node.Kind} {request.Node.Name}.",
            [request.Node.Kind.ToString().ToLowerInvariant()],
            "high",
            new CodeSummaryUsage(
                InputTokens: 100,
                CachedInputTokens: 25,
                CacheWriteInputTokens: 5,
                OutputTokens: 40,
                ReasoningTokens: 10,
                TotalTokens: 140),
            new Dictionary<string, string>
            {
                ["testProviderSetting"] = "configured"
            }));
    }
}

sealed class FakeOllamaSummaryHandler : HttpMessageHandler
{
    public int RequestCount { get; private set; }
    public string LastRequestBody { get; private set; } = string.Empty;

    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request,
        CancellationToken cancellationToken)
    {
        RequestCount++;
        LastRequestBody = request.Content is null
            ? string.Empty
            : await request.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);

        if (request.RequestUri?.AbsolutePath != "/api/chat")
        {
            return new HttpResponseMessage(System.Net.HttpStatusCode.NotFound);
        }

        return new HttpResponseMessage(System.Net.HttpStatusCode.OK)
        {
            Content = new StringContent(
                """
                {
                  "message": {
                    "role": "assistant",
                    "content": "{\"summary\":\"Adds two integers and returns their sum.\",\"tags\":[\"addition\"],\"confidence\":\"high\"}"
                  },
                  "prompt_eval_count": 72,
                  "eval_count": 18
                }
                """,
                System.Text.Encoding.UTF8,
                "application/json")
        };
    }
}

sealed class FakeOllamaEmbeddingHandler : HttpMessageHandler
{
    public int RequestCount { get; private set; }
    public string LastRequestBody { get; private set; } = string.Empty;

    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request,
        CancellationToken cancellationToken)
    {
        RequestCount++;
        LastRequestBody = request.Content is null
            ? string.Empty
            : await request.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);

        if (request.RequestUri?.AbsolutePath != "/api/embed")
        {
            return new HttpResponseMessage(System.Net.HttpStatusCode.NotFound);
        }

        var response = new HttpResponseMessage(System.Net.HttpStatusCode.OK)
        {
            Content = new StringContent(
                """
                {
                  "model": "test-embed",
                  "embeddings": [[0.25, 0.5, 0.75]]
                }
                """,
                System.Text.Encoding.UTF8,
                "application/json")
        };

        return response;
    }
}

sealed class FakeLmStudioEmbeddingHandler : HttpMessageHandler
{
    public int RequestCount { get; private set; }
    public string LastRequestBody { get; private set; } = string.Empty;

    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request,
        CancellationToken cancellationToken)
    {
        RequestCount++;
        LastRequestBody = request.Content is null
            ? string.Empty
            : await request.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);

        if (request.RequestUri?.AbsolutePath != "/v1/embeddings")
        {
            return new HttpResponseMessage(System.Net.HttpStatusCode.NotFound);
        }

        var response = new HttpResponseMessage(System.Net.HttpStatusCode.OK)
        {
            Content = new StringContent(
                """
                {
                  "object": "list",
                  "model": "test-embed",
                  "data": [
                    {
                      "object": "embedding",
                      "index": 0,
                      "embedding": [0.125, 0.25, 0.5]
                    }
                  ]
                }
                """,
                System.Text.Encoding.UTF8,
                "application/json")
        };

        return response;
    }
}

sealed class FakeLmStudioSummaryHandler : HttpMessageHandler
{
    public int RequestCount { get; private set; }
    public string LastRequestBody { get; private set; } = string.Empty;

    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request,
        CancellationToken cancellationToken)
    {
        RequestCount++;
        LastRequestBody = request.Content is null
            ? string.Empty
            : await request.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);

        if (request.RequestUri?.AbsolutePath != "/v1/chat/completions")
        {
            return new HttpResponseMessage(System.Net.HttpStatusCode.NotFound);
        }

        var response = new HttpResponseMessage(System.Net.HttpStatusCode.OK)
        {
            Content = new StringContent(
                """
                {
                  "id": "chatcmpl-test",
                  "object": "chat.completion",
                  "model": "test-summary",
                  "choices": [
                    {
                      "index": 0,
                      "message": {
                        "role": "assistant",
                        "content": "```json\n{\"summary\":\"Trims a URL and converts it to lowercase.\",\"tags\":[\"normalization\",\"url\"],\"confidence\":0.98}\n```"
                      },
                      "finish_reason": "stop"
                    }
                  ],
                  "usage": {
                    "prompt_tokens": 96,
                    "completion_tokens": 24,
                    "total_tokens": 120
                  }
                }
                """,
                System.Text.Encoding.UTF8,
                "application/json")
        };

        return response;
    }
}

sealed class FakeOpenAiSummaryHandler : HttpMessageHandler
{
    private readonly string _responseReasoningEffort;

    public FakeOpenAiSummaryHandler(string responseReasoningEffort = "none")
    {
        _responseReasoningEffort = responseReasoningEffort;
    }

    public int RequestCount { get; private set; }
    public string LastRequestBody { get; private set; } = string.Empty;
    public string? AuthorizationScheme { get; private set; }
    public string? AuthorizationParameter { get; private set; }

    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request,
        CancellationToken cancellationToken)
    {
        RequestCount++;
        LastRequestBody = request.Content is null
            ? string.Empty
            : await request.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
        AuthorizationScheme = request.Headers.Authorization?.Scheme;
        AuthorizationParameter = request.Headers.Authorization?.Parameter;

        if (request.RequestUri?.AbsolutePath != "/v1/responses")
        {
            return new HttpResponseMessage(System.Net.HttpStatusCode.NotFound);
        }

        return new HttpResponseMessage(System.Net.HttpStatusCode.OK)
        {
            Content = new StringContent(
                $$"""
                {
                  "id": "resp_test",
                  "object": "response",
                  "model": "test-summary-snapshot",
                  "status": "completed",
                  "service_tier": "default",
                  "reasoning": {
                    "effort": "{{_responseReasoningEffort}}"
                  },
                  "output": [
                    {
                      "type": "message",
                      "content": [
                        {
                          "type": "output_text",
                          "text": "{\"summary\":\"Adds two integers and returns their sum.\",\"tags\":[\"arithmetic\"],\"confidence\":\"high\"}"
                        }
                      ]
                    }
                  ],
                  "usage": {
                    "input_tokens": 96,
                    "input_tokens_details": {
                      "cached_tokens": 32,
                      "cache_write_tokens": 12
                    },
                    "output_tokens": 24,
                    "output_tokens_details": {
                      "reasoning_tokens": 8
                    },
                    "total_tokens": 120
                  }
                }
                """,
                System.Text.Encoding.UTF8,
                "application/json")
        };
    }
}

sealed class FakeAgentAccessHandler : HttpMessageHandler
{
    public List<(string Method, string Path, string Body)> Requests { get; } = [];

    public bool FailNextRequest { get; set; }

    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request,
        CancellationToken cancellationToken)
    {
        var path = request.RequestUri?.PathAndQuery.TrimStart('/') ?? string.Empty;
        var body = request.Content is null
            ? string.Empty
            : await request.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);

        Requests.Add((request.Method.Method, path, body));

        if (FailNextRequest)
        {
            FailNextRequest = false;
            return JsonResponse(HttpStatusCode.ServiceUnavailable, """{"detail":"offline"}""");
        }

        var payload = request.Method == HttpMethod.Delete
            ? DeletePayload(path)
            : path switch
            {
                "health" or "status" =>
                    """
                {
                  "service": "codemesh-agent-access",
                  "status": "healthy",
                  "checked_at": "2026-06-06T10:00:00Z",
                  "components": {
                    "neo4j": {"status": "healthy"},
                    "mongodb": {"status": "healthy"},
                    "qdrant": {"status": "healthy"},
                    "model_provider": {
                      "provider": "lmstudio",
                      "embedding_model": "text-embedding-nomic-embed-text-v2-moe",
                      "status": "healthy"
                    }
                  }
                }
                """,
                "context/search" =>
                    """
                {
                  "query": {"query": "DownloadAsync", "repository_id": "repo:test"},
                  "hits": [
                    {
                      "node_id": "node:download",
                      "stable_key": "stable:download",
                      "kind": "Method",
                      "file_path": "Downloader.cs",
                      "start_line": 10,
                      "end_line": 20,
                      "score": 0.91
                    }
                  ],
                  "diagnostics": {
                    "mode": "hybrid",
                    "embedding_attempted": true,
                    "embedding_source": "model_provider",
                    "model_provider": "lmstudio",
                    "vector_available": true,
                    "vector_hit_count": 1,
                    "lexical_hit_count": 1,
                    "summary_hit_count": 0,
                    "vector_candidate_count": 1,
                    "lexical_candidate_count": 1,
                    "summary_candidate_count": 0,
                    "lexical_fallback": false,
                    "hit_count": 1
                  },
                  "generated_at": "2026-06-06T10:00:00Z"
                }
                """,
                "context/package" =>
                    """
                {
                  "query": {"query": "DownloadAsync", "repository_id": "repo:test"},
                  "repository": {"repository_id": "repo:test"},
                  "latest_run": {"run_id": "run:test"},
                  "items": [
                    {
                      "hit": {
                        "node_id": "node:download",
                        "stable_key": "stable:download",
                        "kind": "Method",
                        "file_path": "Downloader.cs",
                        "start_line": 10,
                        "end_line": 20,
                        "score": 0.91
                      },
                      "snippet": "return Task.CompletedTask;",
                      "relationships": [],
                      "relationship_groups": {},
                      "rationale": {"rank": 1}
                    }
                  ],
                  "validation_recommendations": [
                    {
                      "id": "dotnet-tests",
                      "command": "dotnet run --project tests/CodeMesh.Tests",
                      "reason": "Run after .NET changes.",
                      "applies_to": ["Downloader.cs"]
                    }
                  ],
                  "total_snippet_characters": 26,
                  "generated_at": "2026-06-06T10:00:00Z"
                }
                """,
                "symbols/search" =>
                    """
                {
                  "query": {"query": "DownloadAsync", "repository_id": "repo:test"},
                  "symbols": [
                    {
                      "node": {"id": "node:download", "name": "DownloadAsync"},
                      "declaration": null,
                      "score": 0.8,
                      "score_components": {"lexical_score": 0.8}
                    }
                  ],
                  "generated_at": "2026-06-06T10:00:00Z"
                }
                """,
                "nodes/get" =>
                    """
                {
                  "node": {"id": "node:download", "kind": "Method"},
                  "content": null,
                  "relationships": []
                }
                """,
                "graph/neighbors" =>
                    """
                {
                  "node": {"id": "node:download", "kind": "Method"},
                  "content": null,
                  "relationships": [
                    {"kind": "Invokes", "target_node_id": "node:callee"}
                  ]
                }
                """,
                "repositories?limit=3" =>
                    """
                {
                  "repositories": [
                    {
                      "repository_id": "repo:test",
                      "alias": "sample_repo",
                      "root_path": "C:/sample",
                      "remote_url": null,
                      "branch": "main",
                      "commit": "abc123",
                      "first_seen_at": "2026-06-06T09:00:00Z",
                      "last_seen_at": "2026-06-06T10:00:00Z",
                      "last_run_id": "run:test",
                      "last_stage": "Completed",
                      "last_message": null,
                      "node_count": 17,
                      "relationship_count": 28,
                      "content_count": 13,
                      "embedding_count": 17,
                      "metadata": {"alias": "sample_repo"}
                    }
                  ]
                }
                """,
                "repositories/sample%20repo%2Fid" =>
                    """
                {
                  "repository_id": "repo:test",
                  "alias": "sample_repo",
                  "root_path": "C:/sample",
                  "remote_url": null,
                  "branch": "main",
                  "commit": "abc123",
                  "first_seen_at": "2026-06-06T09:00:00Z",
                  "last_seen_at": "2026-06-06T10:00:00Z",
                  "last_run_id": "run:test",
                  "last_stage": "Completed",
                  "last_message": null,
                  "node_count": 17,
                  "relationship_count": 28,
                  "content_count": 13,
                  "embedding_count": 17,
                  "metadata": {"alias": "sample_repo"}
                }
                """,
                "repositories/sample%20repo%2Fid/status" =>
                    """
                {
                  "repository_id": "repo:test",
                  "repository": {
                    "repository_id": "repo:test",
                    "alias": "sample_repo",
                    "root_path": "C:/sample",
                    "remote_url": null,
                    "branch": "main",
                    "commit": "abc123",
                    "first_seen_at": "2026-06-06T09:00:00Z",
                    "last_seen_at": "2026-06-06T10:00:00Z",
                    "last_run_id": "run:test",
                    "last_stage": "Completed",
                    "last_message": null,
                    "node_count": 17,
                    "relationship_count": 28,
                    "content_count": 13,
                    "embedding_count": 17,
                    "metadata": {"alias": "sample_repo"}
                  },
                  "latest_run": null,
                  "summary_coverage": null,
                  "counts": {"graph_nodes": 17, "relationships": 28, "content_documents": 13, "vectors": 17},
                  "freshness": {"status": "fresh", "is_stale": false, "indexed_commit": "abc123", "current_commit": "abc123"},
                  "refresh": {"status": "completed", "latest_run_id": "run:test", "changed": true, "is_running": false},
                  "generated_at": "2026-06-06T10:10:00Z"
                }
                """,
                "repositories/sample%20repo%2Fid/summaries" =>
                    """
                {
                  "repository_id": "repo:test",
                  "total_count": 6,
                  "completed_count": 5,
                  "failed_count": 1,
                  "status_counts": {"completed": 5, "failed": 1},
                  "kind_counts": {"Method": 2, "Class": 1, "File": 1, "Property": 1},
                  "provider_model_counts": {"lmstudio/qwen/qwen2.5-coder-14b/node-summary-v1": 6},
                  "provider_model_count_details": [
                    {"provider": "lmstudio", "model": "qwen/qwen2.5-coder-14b", "prompt_version": "node-summary-v1", "count": 6}
                  ],
                  "recent_failures": [
                    {"node_id": "node:failed", "error": "model failed"}
                  ],
                  "generated_at": "2026-06-06T10:10:00Z"
                }
                """,
                "ingestion-runs?limit=2&repository_id=sample%20repo%2Fid" =>
                    """
                {
                  "runs": [
                    {
                      "run_id": "run:test",
                      "repository_id": "repo:test",
                      "repository_root": "C:/sample",
                      "stage": "Completed",
                      "started_at": "2026-06-06T09:00:00Z",
                      "finished_at": "2026-06-06T10:00:00Z",
                      "message": null,
                      "language": "csharp",
                      "parser_name": "CodeMesh.Parser.CSharp",
                      "solution_path": "C:/sample/Sample.sln",
                      "project_path": null,
                      "dry_run": false,
                      "skip_embeddings": false,
                      "embedding_provider": "lmstudio",
                      "embedding_model": "text-embedding-nomic-embed-text-v2-moe",
                      "node_count": 17,
                      "relationship_count": 28,
                      "content_count": 13,
                      "embedding_count": 17,
                      "stats": {"parsed_node_count": 17},
                      "diagnostic_count": 0,
                      "error_diagnostic_count": 0,
                      "warning_diagnostic_count": 0,
                      "metadata": {"alias": "sample_repo"}
                    }
                  ]
                }
                """,
                _ => string.Empty
            };

        return string.IsNullOrEmpty(payload)
            ? JsonResponse(HttpStatusCode.NotFound, """{"detail":"not found"}""")
            : JsonResponse(HttpStatusCode.OK, payload);
    }

    private static string DeletePayload(string path)
    {
        return path switch
        {
            "repositories/sample%20repo%2Fid" =>
                """
                {
                  "repository_id": "repo:test",
                  "deleted": true,
                  "registry_entry_existed": true,
                  "graph_cleaned": true,
                  "content_cleaned": true,
                  "embeddings_cleaned": true,
                  "summaries_cleaned": true
                }
                """,
            _ => string.Empty
        };
    }

    private static HttpResponseMessage JsonResponse(HttpStatusCode statusCode, string payload)
        => new(statusCode)
        {
            Content = new StringContent(payload, Encoding.UTF8, "application/json")
        };
}