Fix Codex session persistence and upstream sync

Fixes #4

Fixes #5

Fixes #6

Fixes #10

Author: KSemenenko

.github/workflows/codex-cli-watch.yml

@@ -32,8 +32,11 @@ jobs:
           set -euo pipefail
 
           SUBMODULE_PATH="submodules/openai-codex"
-          MODELS_FILE="codex-rs/core/models.json"
           CONFIG_SCHEMA_FILE="codex-rs/core/config.schema.json"
+          MODEL_SOURCE_PATHS=(
+            "codex-rs/models-manager/models.json"
+            "codex-rs/core/models.json"
+          )
           FLAG_SOURCE_PATHS=(
             "codex-rs/cli/src/main.rs"
             "codex-rs/exec/src/cli.rs"
@@ -46,6 +49,21 @@ jobs:
             git -C "$SUBMODULE_PATH" show "$sha:$path" 2>/dev/null || true
           }
 
+          read_first_existing_file_at_sha() {
+            local sha="$1"
+            shift
+            local path
+
+            for path in "$@"; do
+              if git -C "$SUBMODULE_PATH" cat-file -e "$sha:$path" 2>/dev/null; then
+                read_file_at_sha "$sha" "$path"
+                return 0
+              fi
+            done
+
+            return 0
+          }
+
           extract_flag_snapshot() {
             local sha="$1"
             local path
@@ -57,7 +75,7 @@ jobs:
 
           extract_model_snapshot() {
             local sha="$1"
-            read_file_at_sha "$sha" "$MODELS_FILE" \
+            read_first_existing_file_at_sha "$sha" "${MODEL_SOURCE_PATHS[@]}" \
               | jq -r '.models[]? | (.id // .slug // empty)' \
               | sed '/^$/d' \
               | sort -u || true
@@ -250,7 +268,8 @@ jobs:
               per_page: 100,
             });
 
-            const duplicate = openIssues.find(issue =>
+            const syncIssues = openIssues.filter(issue => !issue.pull_request);
+            const duplicate = syncIssues.find(issue =>
               !issue.pull_request && issue.body && issue.body.includes(marker)
             );
 
@@ -259,6 +278,11 @@ jobs:
               return;
             }
 
+            const reusableIssue = [...syncIssues]
+              .sort((left, right) => {
+                return new Date(right.updated_at).getTime() - new Date(left.updated_at).getTime();
+              })[0];
+
             const title = `Sync Codex CLI upstream changes (${shortCurrent} -> ${shortLatest})`;
             const body = [
               marker,
@@ -289,6 +313,7 @@ jobs:
               '',
               '## Action required',
               '- [ ] Validate latest `codex --help` and `codex exec --help` output',
+              '- [ ] Validate latest `codex features list` output',
               '- [ ] Sync C# SDK constants/options/models with upstream CLI changes',
               '- [ ] Add or update tests for new flags/models/features',
               '- [ ] Update docs (README + docs/Features + docs/Architecture if needed)',
@@ -297,31 +322,80 @@ jobs:
             ].join('\n');
 
             let issue;
-            try {
-              issue = await github.rest.issues.create({
+            if (reusableIssue) {
+              issue = await github.rest.issues.update({
                 owner: context.repo.owner,
                 repo: context.repo.repo,
+                issue_number: reusableIssue.number,
                 title,
                 body,
                 labels: [labelName],
-                assignees: [assignee],
               });
-              core.info(`Created and assigned issue #${issue.data.number} to @${assignee}`);
-            } catch (error) {
-              core.warning(`Issue assignment failed (${error.message}), creating without assignee.`);
-              issue = await github.rest.issues.create({
+
+              try {
+                await github.rest.issues.addAssignees({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: reusableIssue.number,
+                  assignees: [assignee],
+                });
+                core.info(`Updated existing sync issue #${reusableIssue.number} and assigned @${assignee}`);
+              } catch (error) {
+                core.warning(`Issue assignment failed (${error.message}) for #${reusableIssue.number}.`);
+                await github.rest.issues.createComment({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: reusableIssue.number,
+                  body: `Could not auto-assign @${assignee}. Please assign manually.`,
+                });
+              }
+            } else {
+              try {
+                issue = await github.rest.issues.create({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  title,
+                  body,
+                  labels: [labelName],
+                  assignees: [assignee],
+                });
+                core.info(`Created and assigned issue #${issue.data.number} to @${assignee}`);
+              } catch (error) {
+                core.warning(`Issue assignment failed (${error.message}), creating without assignee.`);
+                issue = await github.rest.issues.create({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  title,
+                  body,
+                  labels: [labelName],
+                });
+
+                await github.rest.issues.createComment({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: issue.data.number,
+                  body: `Could not auto-assign @${assignee}. Please assign manually.`,
+                });
+              }
+            }
+
+            for (const staleIssue of syncIssues) {
+              if (staleIssue.number === issue.data.number) {
+                continue;
+              }
+
+              await github.rest.issues.createComment({
                 owner: context.repo.owner,
                 repo: context.repo.repo,
-                title,
-                body,
-                labels: [labelName],
+                issue_number: staleIssue.number,
+                body: `Superseded by #${issue.data.number} for newer upstream Codex CLI commit \`${shortLatest}\`.`,
               });
 
-              await github.rest.issues.createComment({
+              await github.rest.issues.update({
                 owner: context.repo.owner,
                 repo: context.repo.repo,
-                issue_number: issue.data.number,
-                body: `Could not auto-assign @${assignee}. Please assign manually.`,
+                issue_number: staleIssue.number,
+                state: 'closed',
               });
             }
 

AGENTS.md

@@ -90,7 +90,7 @@ If no new rule is detected -> do not update the file.
 - Do not keep or add public sample projects; repository focus is SDK + tests only.
 - Upstream sync automation must track real `openai/codex` CLI changes (flags/models/features), not TypeScript SDK surface diffs, and open actionable repository issues for required SDK follow-up.
 - Automatically opened upstream sync issues must include change summary/checklist and assign Copilot by default.
-- For `openai/codex` repo sync/update work, always inspect `submodules/openai-codex/codex-rs/core/models.json` and reconcile SDK model constants against that bundled catalog because it is the repo-authoritative model source.
+- For `openai/codex` repo sync/update work, always inspect the bundled `models.json` catalog in `submodules/openai-codex` (prefer `codex-rs/models-manager/models.json`, fall back to `codex-rs/core/models.json` for older pins) and reconcile SDK model constants against that repo-authoritative source.
 - At the end of implementation/code-change tasks, create a git commit unless the user explicitly says not to, so the workspace ends in a reviewable state.
 - Run verification in this order:
   - focused tests for changed behavior

CodexSharpSDK.Tests/Integration/RealCodexIntegrationTests.cs

@@ -1,4 +1,6 @@
+using System.Text.Json.Nodes;
 using ManagedCode.CodexSharpSDK.Client;
+using ManagedCode.CodexSharpSDK.Configuration;
 using ManagedCode.CodexSharpSDK.Models;
 using ManagedCode.CodexSharpSDK.Tests.Shared;
 
@@ -90,6 +92,43 @@ public async Task RunAsync_WithRealCodexCli_SecondTurnKeepsThreadId()
         await Assert.That(thread.Id).IsEqualTo(firstThreadId);
     }
 
+    [Test]
+    public async Task RunAsync_WithExplicitNonEphemeralOverride_PersistsRolloutWhenClientConfigEnablesEphemeral()
+    {
+        var settings = RealCodexTestSupport.GetRequiredSettings();
+
+        using var client = RealCodexTestSupport.CreateClient(new CodexOptions
+        {
+            Config = new JsonObject
+            {
+                ["ephemeral"] = true,
+            },
+        });
+        var thread = client.StartThread(new ThreadOptions
+        {
+            Model = settings.Model,
+            ModelReasoningEffort = ModelReasoningEffort.Medium,
+            WebSearchMode = WebSearchMode.Disabled,
+            SandboxMode = SandboxMode.WorkspaceWrite,
+            NetworkAccessEnabled = true,
+            Ephemeral = false,
+        });
+        using var cancellation = new CancellationTokenSource(TimeSpan.FromMinutes(2));
+
+        var result = await thread.RunAsync(
+            "Reply with short plain text: ok.",
+            new TurnOptions { CancellationToken = cancellation.Token });
+
+        await Assert.That(result.Usage).IsNotNull();
+        await Assert.That(thread.Id).IsNotNull();
+
+        var rolloutPath = await RealCodexTestSupport.FindPersistedRolloutPathAsync(
+            thread.Id!,
+            TimeSpan.FromSeconds(10));
+
+        await Assert.That(rolloutPath).IsNotNull();
+    }
+
     private static CodexThread StartRealIntegrationThread(CodexClient client, string model)
     {
         return client.StartThread(new ThreadOptions

CodexSharpSDK.Tests/Shared/RealCodexTestSupport.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics;
 using ManagedCode.CodexSharpSDK.Client;
 using ManagedCode.CodexSharpSDK.Configuration;
 using ManagedCode.CodexSharpSDK.Internal;
@@ -19,9 +20,36 @@ public static RealCodexTestSettings GetRequiredSettings()
         return new RealCodexTestSettings(ResolveModel());
     }
 
-    public static CodexClient CreateClient()
+    public static CodexClient CreateClient(CodexOptions? options = null)
     {
-        return new CodexClient(new CodexOptions());
+        return new CodexClient(options ?? new CodexOptions());
+    }
+
+    public static async Task<string?> FindPersistedRolloutPathAsync(string threadId, TimeSpan timeout)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(threadId);
+
+        var sessionsPath = GetCodexSessionsPath();
+        if (sessionsPath is null || !Directory.Exists(sessionsPath))
+        {
+            return null;
+        }
+
+        var stopwatch = Stopwatch.StartNew();
+        while (stopwatch.Elapsed < timeout)
+        {
+            var rolloutPath = Directory
+                .EnumerateFiles(sessionsPath, $"rollout-*{threadId}.jsonl", SearchOption.AllDirectories)
+                .FirstOrDefault();
+            if (!string.IsNullOrWhiteSpace(rolloutPath))
+            {
+                return rolloutPath;
+            }
+
+            await Task.Delay(TimeSpan.FromMilliseconds(200)).ConfigureAwait(false);
+        }
+
+        return null;
     }
 
     private static string ResolveModel()
@@ -108,6 +136,17 @@ private static string ResolveModel()
         return Path.Combine(homeDirectory, ".codex", "config.toml");
     }
 
+    private static string? GetCodexSessionsPath()
+    {
+        var homeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+        if (string.IsNullOrWhiteSpace(homeDirectory))
+        {
+            return null;
+        }
+
+        return Path.Combine(homeDirectory, ".codex", "sessions");
+    }
+
     private static bool IsCodexAvailable()
     {
         var resolvedPath = CodexCliLocator.FindCodexPath(null);

CodexSharpSDK.Tests/Unit/CodexExecTests.cs

@@ -151,6 +151,28 @@ public async Task BuildCommandArgs_MapsExtendedCliFlags()
         await Assert.That(commandArgs.Contains("custom-value")).IsTrue();
     }
 
+    [Test]
+    public async Task BuildCommandArgs_ExplicitFalseEphemeral_OverridesConfigPersistence()
+    {
+        var exec = new CodexExec(
+            executablePath: "codex",
+            environmentOverride: null,
+            configOverrides: new JsonObject
+            {
+                ["ephemeral"] = true,
+            });
+
+        var commandArgs = exec.BuildCommandArgs(new CodexExecArgs
+        {
+            Input = "test",
+            Ephemeral = false,
+        });
+
+        await Assert.That(commandArgs.Contains("--ephemeral")).IsFalse();
+        await Assert.That(CollectConfigValues(commandArgs, "ephemeral"))
+            .IsEquivalentTo(["ephemeral=true", "ephemeral=false"]);
+    }
+
     [Test]
     public async Task BuildCommandArgs_KeepsConfiguredWebSearchWhenThreadOverridesMissing()
     {

CodexSharpSDK.Tests/Unit/CodexModelsTests.cs

@@ -8,6 +8,11 @@ public class CodexModelsTests
 {
     private const string SolutionFileName = "ManagedCode.CodexSharpSDK.slnx";
     private const string BundledModelsFileName = "models.json";
+    private static readonly string[] BundledModelsRelativePaths =
+    [
+        Path.Combine("submodules", "openai-codex", "codex-rs", "models-manager", BundledModelsFileName),
+        Path.Combine("submodules", "openai-codex", "codex-rs", "core", BundledModelsFileName),
+    ];
 
     [Test]
     public async Task CodexModels_ContainAllBundledUpstreamModelSlugs()
@@ -17,8 +22,12 @@ public async Task CodexModels_ContainAllBundledUpstreamModelSlugs()
         var missingBundledSlugs = bundledModelSlugs
             .Except(sdkModelSlugs, StringComparer.Ordinal)
             .ToArray();
+        var extraSdkSlugs = sdkModelSlugs
+            .Except(bundledModelSlugs, StringComparer.Ordinal)
+            .ToArray();
 
         await Assert.That(missingBundledSlugs).IsEmpty();
+        await Assert.That(extraSdkSlugs).IsEmpty();
     }
 
     private static string[] GetSdkModelSlugs()
@@ -46,13 +55,17 @@ private static async Task<string[]> ReadBundledModelSlugsAsync()
 
     private static string ResolveBundledModelsFilePath()
     {
-        return Path.Combine(
-            ResolveRepositoryRootPath(),
-            "submodules",
-            "openai-codex",
-            "codex-rs",
-            "core",
-            BundledModelsFileName);
+        var repositoryRootPath = ResolveRepositoryRootPath();
+        foreach (var relativePath in BundledModelsRelativePaths)
+        {
+            var candidatePath = Path.Combine(repositoryRootPath, relativePath);
+            if (File.Exists(candidatePath))
+            {
+                return candidatePath;
+            }
+        }
+
+        throw new InvalidOperationException("Could not locate bundled upstream models.json under the openai-codex submodule.");
     }
 
     private static string ResolveRepositoryRootPath()