Add Gemini session visibility regression test

Author: KSemenenko

AGENTS.md

@@ -133,6 +133,7 @@ If no new rule is detected -> do not update the file.
 - CI/release full-solution runs must exclude auth-required tests using `-- --treenode-filter "/*/*/*/*[RequiresGeminiAuth!=true]"` so pipelines remain non-auth and deterministic.
 - Cross-platform non-auth smoke must run `gemini` from local installation in CI and verify unauthenticated behavior explicitly (for example `gemini login status` in isolated profile returns "Not logged in"), proving binary discovery + process launch on each platform.
 - Real Gemini integration tests must rely on existing local Gemini CLI login/session only; do not read or require `OPENAI_API_KEY` in test setup.
+- For local authenticated Gemini verification, prefer the cheapest available Gemini model that works in the current account/environment to keep testing costs down.
 - Adapter regression coverage is critical: when CLI contract changes affect streaming/events/options, keep the `Extensions.AI` and `Extensions.AgentFramework` tests green in the same pass.
 - Do not use nullable `TryGetSettings()` + early `return` skip patterns in real integration tests; resolve required settings directly and fail fast with actionable errors when missing.
 - Do not bypass integration tests on Windows with unconditional early returns; keep tests cross-platform for supported Gemini CLI environments.
@@ -206,6 +207,7 @@ If no new rule is detected -> do not update the file.
 
 - Read `AGENTS.md` and relevant docs before editing code.
 - Keep API behavior aligned with actual Gemini CLI contracts first; TypeScript SDK mapping may be used only as an optional historical reference, not as a blocker for C# SDK design.
+- For `ManagedCode.GeminiSharpSDK`, do not import Codex-specific behavior, docs, or assumptions into implementation or tests unless the user explicitly asks for cross-SDK comparison; keep Gemini fixes grounded in real Gemini CLI behavior.
 - Maintain GitHub workflow health (`.github/workflows`).
 
 **Ask first:**

GeminiSharpSDK.Tests/Integration/RealGeminiIntegrationTests.cs

@@ -1,4 +1,7 @@
+using System.Diagnostics;
+using System.Text.Json;
 using ManagedCode.GeminiSharpSDK.Client;
+using ManagedCode.GeminiSharpSDK.Internal;
 using ManagedCode.GeminiSharpSDK.Models;
 using ManagedCode.GeminiSharpSDK.Tests.Shared;
 
@@ -7,6 +10,26 @@ namespace ManagedCode.GeminiSharpSDK.Tests.Integration;
 [Property("RequiresGeminiAuth", "true")]
 public class RealGeminiIntegrationTests
 {
+    private const string SolutionFileName = "ManagedCode.GeminiSharpSDK.slnx";
+    private const string TestsDirectoryName = "tests";
+    private const string SandboxDirectoryName = ".sandbox";
+    private const string SandboxPrefix = "RealGeminiIntegrationTests-SessionVisibility-";
+    private const string GitExecutableName = "git";
+    private const string GitInitArgument = "init";
+    private const string QuietArgument = "-q";
+    private const string ListSessionsFlag = "--list-sessions";
+    private const string GeminiDirectoryName = ".gemini";
+    private const string ProjectsFileName = "projects.json";
+    private const string ProjectsPropertyName = "projects";
+    private const string TmpDirectoryName = "tmp";
+    private const string ChatsDirectoryName = "chats";
+    private const string SessionIdPropertyName = "sessionId";
+    private const string SessionFileSearchPattern = "session-*.json";
+    private const string ProjectSessionVisiblePrompt = "Reply with short plain text: ok.";
+    private static readonly TimeSpan SessionVisibilityTimeout = TimeSpan.FromSeconds(10);
+    private static readonly TimeSpan CliCommandTimeout = TimeSpan.FromSeconds(30);
+    private static readonly TimeSpan PollInterval = TimeSpan.FromMilliseconds(200);
+
     [Test]
     public async Task RunAsync_WithRealGeminiCli_ReturnsStructuredOutput()
     {
@@ -90,11 +113,255 @@ public async Task RunAsync_WithRealGeminiCli_SecondTurnKeepsThreadId()
         await Assert.That(thread.Id).IsEqualTo(firstThreadId);
     }
 
+    [Test]
+    public async Task RunAsync_WithFreshWorkingDirectory_PersistsSessionVisibleToGeminiCli()
+    {
+        var settings = RealGeminiTestSupport.GetRequiredSettings();
+        var sandboxDirectory = await CreateGitSandboxDirectoryAsync();
+
+        try
+        {
+            using var client = RealGeminiTestSupport.CreateClient();
+            var thread = client.StartThread(new ThreadOptions
+            {
+                Model = settings.Model,
+                WorkingDirectory = sandboxDirectory,
+                Ephemeral = false,
+            });
+            using var cancellation = new CancellationTokenSource(TimeSpan.FromMinutes(2));
+
+            var result = await thread.RunAsync(
+                ProjectSessionVisiblePrompt,
+                new TurnOptions { CancellationToken = cancellation.Token });
+
+            await Assert.That(result.Usage).IsNotNull();
+            await Assert.That(thread.Id).IsNotNull();
+
+            var persistedSessionPath = await FindPersistedSessionPathAsync(
+                sandboxDirectory,
+                thread.Id!,
+                SessionVisibilityTimeout);
+
+            await Assert.That(persistedSessionPath).IsNotNull();
+
+            var listSessionsResult = await RunGeminiAsync(
+                sandboxDirectory,
+                CliCommandTimeout,
+                ListSessionsFlag);
+
+            await Assert.That(listSessionsResult.ExitCode).IsEqualTo(0);
+            await Assert.That(string.Concat(listSessionsResult.StandardOutput, listSessionsResult.StandardError))
+                .Contains(thread.Id!);
+        }
+        finally
+        {
+            if (Directory.Exists(sandboxDirectory))
+            {
+                Directory.Delete(sandboxDirectory, recursive: true);
+            }
+        }
+    }
+
     private static GeminiThread StartRealIntegrationThread(GeminiClient client, string model)
     {
         return client.StartThread(new ThreadOptions
         {
             Model = model,
         });
     }
+
+    private static async Task<string> CreateGitSandboxDirectoryAsync()
+    {
+        var repositoryRoot = ResolveRepositoryRootPath();
+        var sandboxDirectory = Path.Combine(
+            repositoryRoot,
+            TestsDirectoryName,
+            SandboxDirectoryName,
+            $"{SandboxPrefix}{Guid.NewGuid():N}");
+
+        Directory.CreateDirectory(sandboxDirectory);
+        var gitInitResult = await RunCommand(
+            GitExecutableName,
+            sandboxDirectory,
+            CliCommandTimeout,
+            GitInitArgument,
+            QuietArgument);
+
+        if (gitInitResult.ExitCode != 0)
+        {
+            throw new InvalidOperationException(
+                $"Failed to initialize git sandbox: {gitInitResult.StandardError}");
+        }
+
+        return sandboxDirectory;
+    }
+
+    private static string ResolveRepositoryRootPath()
+    {
+        var current = new DirectoryInfo(AppContext.BaseDirectory);
+        while (current is not null)
+        {
+            if (File.Exists(Path.Combine(current.FullName, SolutionFileName)))
+            {
+                return current.FullName;
+            }
+
+            current = current.Parent;
+        }
+
+        throw new InvalidOperationException("Could not locate repository root from test execution directory.");
+    }
+
+    private static async Task<string?> FindPersistedSessionPathAsync(
+        string workingDirectory,
+        string threadId,
+        TimeSpan timeout)
+    {
+        var deadline = DateTime.UtcNow + timeout;
+        while (DateTime.UtcNow <= deadline)
+        {
+            var persistedSessionPath = TryFindPersistedSessionPath(workingDirectory, threadId);
+            if (persistedSessionPath is not null)
+            {
+                return persistedSessionPath;
+            }
+
+            await Task.Delay(PollInterval);
+        }
+
+        return null;
+    }
+
+    private static string? TryFindPersistedSessionPath(string workingDirectory, string threadId)
+    {
+        var projectKey = TryResolveProjectKey(workingDirectory);
+        if (string.IsNullOrWhiteSpace(projectKey))
+        {
+            return null;
+        }
+
+        var geminiHome = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+            GeminiDirectoryName);
+        var chatsDirectory = Path.Combine(geminiHome, TmpDirectoryName, projectKey, ChatsDirectoryName);
+        if (!Directory.Exists(chatsDirectory))
+        {
+            return null;
+        }
+
+        foreach (var sessionFile in Directory.EnumerateFiles(chatsDirectory, SessionFileSearchPattern, SearchOption.TopDirectoryOnly))
+        {
+            if (SessionFileMatchesThreadId(sessionFile, threadId))
+            {
+                return sessionFile;
+            }
+        }
+
+        return null;
+    }
+
+    private static string? TryResolveProjectKey(string workingDirectory)
+    {
+        var projectsPath = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+            GeminiDirectoryName,
+            ProjectsFileName);
+        if (!File.Exists(projectsPath))
+        {
+            return null;
+        }
+
+        using var stream = File.OpenRead(projectsPath);
+        using var document = JsonDocument.Parse(stream);
+        if (!document.RootElement.TryGetProperty(ProjectsPropertyName, out var projectsElement)
+            || projectsElement.ValueKind != JsonValueKind.Object)
+        {
+            return null;
+        }
+
+        var normalizedWorkingDirectory = Path.GetFullPath(workingDirectory);
+        foreach (var project in projectsElement.EnumerateObject())
+        {
+            if (!string.Equals(Path.GetFullPath(project.Name), normalizedWorkingDirectory, StringComparison.Ordinal))
+            {
+                continue;
+            }
+
+            return project.Value.ValueKind == JsonValueKind.String
+                ? project.Value.GetString()
+                : null;
+        }
+
+        return null;
+    }
+
+    private static bool SessionFileMatchesThreadId(string sessionFile, string threadId)
+    {
+        using var stream = File.OpenRead(sessionFile);
+        using var document = JsonDocument.Parse(stream);
+        return document.RootElement.TryGetProperty(SessionIdPropertyName, out var sessionIdElement)
+               && sessionIdElement.ValueKind == JsonValueKind.String
+               && string.Equals(sessionIdElement.GetString(), threadId, StringComparison.Ordinal);
+    }
+
+    private static Task<GeminiCommandResult> RunGeminiAsync(
+        string workingDirectory,
+        TimeSpan timeout,
+        params string[] arguments)
+    {
+        var executablePath = GeminiCliLocator.FindGeminiPath(null);
+        return RunCommand(executablePath, workingDirectory, timeout, arguments);
+    }
+
+    private static async Task<GeminiCommandResult> RunCommand(
+        string executablePath,
+        string workingDirectory,
+        TimeSpan timeout,
+        params string[] arguments)
+    {
+        using var cancellation = new CancellationTokenSource(timeout);
+        var startInfo = new ProcessStartInfo(executablePath)
+        {
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            UseShellExecute = false,
+            CreateNoWindow = true,
+            WorkingDirectory = workingDirectory,
+        };
+
+        foreach (var argument in arguments)
+        {
+            if (string.IsNullOrWhiteSpace(argument))
+            {
+                continue;
+            }
+
+            startInfo.ArgumentList.Add(argument);
+        }
+
+        using var process = new Process { StartInfo = startInfo };
+        try
+        {
+            if (!process.Start())
+            {
+                throw new InvalidOperationException($"Failed to start command '{executablePath}'.");
+            }
+        }
+        catch (Exception exception)
+        {
+            throw new InvalidOperationException($"Failed to start command '{executablePath}'.", exception);
+        }
+
+        var standardOutputTask = process.StandardOutput.ReadToEndAsync(cancellation.Token);
+        var standardErrorTask = process.StandardError.ReadToEndAsync(cancellation.Token);
+
+        await process.WaitForExitAsync(cancellation.Token);
+
+        return new GeminiCommandResult(
+            process.ExitCode,
+            await standardOutputTask,
+            await standardErrorTask);
+    }
+
+    private sealed record GeminiCommandResult(int ExitCode, string StandardOutput, string StandardError);
 }

README.md

@@ -81,6 +81,8 @@ var thread = client.StartThread(new ThreadOptions
 
 `ThreadOptions` maps to the current headless Gemini CLI surface (`--prompt`, `--output-format stream-json`, `--resume`, `--approval-mode`, `--include-directories`, and sandbox toggle). Unsupported legacy flags fail fast.
 
+Fresh SDK-started runs persist per Gemini project/working directory and are visible via `gemini --list-sessions` for that same project.
+
 ```csharp
 var thread = client.StartThread(new ThreadOptions
 {

docs/Features/thread-run-flow.md

@@ -45,6 +45,7 @@ Provide deterministic thread-based execution over Gemini CLI so C# consumers can
 - `LocalImageInput` accepts image path, `FileInfo`, or `Stream`; stream inputs are materialized to temp files and referenced in the prompt as local `@path` inputs.
 - Gemini executable resolution is deterministic: prefer npm-vendored native binary, then PATH lookup; on Windows PATH lookup checks `gemini.exe`, `gemini.cmd`, `gemini.bat`, then `gemini`.
 - Thread options map only the current supported headless Gemini CLI flags (`model`, `resume`, `approval-mode`, `include-directories`, sandbox toggle), plus raw `AdditionalCliArguments` passthrough for forward-compatible flags.
+- A fresh SDK-started Gemini run with a dedicated working directory persists a resumable session file and is visible through `gemini --list-sessions` for that same project.
 - Unsupported legacy headless flags fail fast with actionable `NotSupportedException`.
 - Cleanup failures are never silently swallowed; process/schema/image cleanup issues are logged through `ILogger`.
 
@@ -109,6 +110,7 @@ flowchart LR
 - Protocol parsing: [ThreadEventParserTests.cs](../../GeminiSharpSDK.Tests/Unit/ThreadEventParserTests.cs)
 - CLI argument mapping: [GeminiExecTests.cs](../../GeminiSharpSDK.Tests/Unit/GeminiExecTests.cs)
 - Client lifecycle: [GeminiClientTests.cs](../../GeminiSharpSDK.Tests/Unit/GeminiClientTests.cs)
+- Real session persistence visibility: [RealGeminiIntegrationTests.cs](../../GeminiSharpSDK.Tests/Integration/RealGeminiIntegrationTests.cs)
 
 ---