fix: .go-entry survival across extract; add stale E2E driving mtime-unchanged immediate; verification re-ran clean

Author: kzu

src/Tests/EndToEndTests.cs

@@ -224,4 +224,62 @@ static string CreateTempDir()
         Directory.CreateDirectory(dir);
         return dir;
     }
+
+    [Fact]
+    public void Remote_stale_2week_re_download_refreshes_mtime_immediate_followup_does_not()
+    {
+        var scratch = @"C:\Users\kzu\AppData\Local\Temp\grok-goal-4376de8fe197\implementer";
+        Directory.CreateDirectory(scratch);
+        var remoteRef = "gist.github.com/kzu/0ac826dc7de666546aaedd38e5965381";
+        var logPath = Path.Combine(scratch, "stale-download.log");
+
+        // Ensure clean-ish start for this ref's cache dir (best effort)
+        try { RunGo("clean", remoteRef); } catch { }
+
+        // Warm-up download
+        var warm = RunGo(remoteRef, "--", "-v:q");
+        Assert.Equal(0, warm.ExitCode);
+        Assert.Contains("run.cs", warm.Output);
+
+        // Locate the downloaded source cs for this ref (uses the same base as production)
+        var goRoot = GetTempRoot();
+        var gistRoot = Directory.GetDirectories(goRoot, "*", SearchOption.AllDirectories)
+            .FirstOrDefault(d => d.Replace('\\', '/').Contains("gist.github.com/kzu/0ac826dc7de666546aaedd38e5965381"));
+        Assert.False(string.IsNullOrEmpty(gistRoot), "expected download dir for gist ref");
+        var sourceCs = Directory.GetFiles(gistRoot, "run.cs", SearchOption.AllDirectories).FirstOrDefault()
+            ?? Directory.GetFiles(gistRoot, "*.cs", SearchOption.AllDirectories).FirstOrDefault();
+        Assert.False(string.IsNullOrEmpty(sourceCs), "expected source .cs under download");
+        var srcInfo = new FileInfo(sourceCs);
+
+        // Artificially age it >14 days
+        var staleTime = DateTime.UtcNow.AddDays(-20);
+        srcInfo.LastWriteTimeUtc = staleTime;
+        Assert.True((DateTime.UtcNow - srcInfo.LastWriteTimeUtc).TotalDays > 14);
+
+        // Re-invoke: should detect stale, (re)download/touch mtime to recent, succeed with marker
+        var (exitStale, outStale) = RunGo(remoteRef, "--", "-v:q");
+        File.WriteAllText(logPath, "STALE-RE-INVOKE:\n" + outStale);
+        Assert.Equal(0, exitStale);
+        Assert.Contains("run.cs", outStale);
+
+        srcInfo.Refresh();
+        var afterStaleMtime = srcInfo.LastWriteTimeUtc;
+        File.AppendAllText(logPath, $"\nSOURCE-MTIME-AFTER-STALE: {afterStaleMtime:O}\n");
+        Assert.True((DateTime.UtcNow - afterStaleMtime).TotalMinutes < 5, "source mtime should be refreshed to recent by re-dl");
+
+        // Immediate follow-up: must NOT update the source mtime (plan requirement)
+        var mtimeBeforeImmediate = srcInfo.LastWriteTimeUtc;
+        var (exitImm, outImm) = RunGo(remoteRef, "--", "-v:q");
+        File.AppendAllText(logPath, "IMMEDIATE-FOLLOWUP:\n" + outImm);
+        Assert.Equal(0, exitImm);
+        Assert.Contains("run.cs", outImm);
+
+        srcInfo.Refresh();
+        var mtimeAfterImmediate = srcInfo.LastWriteTimeUtc;
+        File.AppendAllText(logPath, $"SOURCE-MTIME-AFTER-IMMEDIATE: {mtimeAfterImmediate:O}\n");
+
+        var deltaSeconds = (mtimeAfterImmediate - mtimeBeforeImmediate).TotalSeconds;
+        // The immediate run (cache hit, no dl) must not have updated the source mtime via our logic or observable change.
+        Assert.True(deltaSeconds < 2.0, $"immediate follow-up must not update source mtime (delta={deltaSeconds}s)");
+    }
 }

src/go/RemoteSourceResolver.cs

@@ -48,6 +48,20 @@ public static string GetRemoteEntryPointPath(RemoteRef remote)
             if (!string.IsNullOrEmpty(name))
                 return Path.Combine(remote.TempPath, name.Replace('/', Path.DirectorySeparatorChar));
         }
+
+        // Robust discovery (handles case where ExtractToAsync deleted the dir + marker on re-dl, or marker missing for other reason):
+        // If files are already present on disk, pick the first .cs (so we don't resolve to non-existent "program.cs" and force spurious dl).
+        if (Directory.Exists(remote.TempPath))
+        {
+            var first = Directory.EnumerateFiles(remote.TempPath, "*.cs", SearchOption.TopDirectoryOnly).FirstOrDefault();
+            if (first != null)
+            {
+                var name = Path.GetFileName(first);
+                try { File.WriteAllText(marker, name); } catch { }
+                return first;
+            }
+        }
+
         return Path.Combine(remote.TempPath, "program.cs");
     }
 
@@ -104,19 +118,21 @@ internal static async Task<string> DownloadIfNeededAsync(RemoteRef remote, bool
                 contents?.Dispose();
             }
 
-            // After possible extract, pick actual entry if Path not specified and default candidate missing
-            if (!File.Exists(candidate) && remote.Path is null)
+            // After (possible) extract on a download path, (re)determine the actual entry point and (re)write the .go-entry marker.
+            // This guarantees the marker survives ExtractToAsync's Directory.Delete of the entire TempPath.
+            // We no longer rely solely on the pre-dl 'candidate' value for the existence check.
+            if (remote.Path is null)
             {
-                var firstCs = Directory.EnumerateFiles(remote.TempPath, "*.cs", SearchOption.TopDirectoryOnly).FirstOrDefault();
-                if (firstCs != null)
+                var prog = Path.Combine(remote.TempPath, "program.cs");
+                var chosen = File.Exists(prog)
+                    ? prog
+                    : (Directory.EnumerateFiles(remote.TempPath, "*.cs", SearchOption.TopDirectoryOnly).FirstOrDefault() ?? prog);
+                candidate = chosen;
+                try
                 {
-                    candidate = firstCs;
-                    try
-                    {
-                        File.WriteAllText(Path.Combine(remote.TempPath, ".go-entry"), Path.GetFileName(candidate));
-                    }
-                    catch { }
+                    File.WriteAllText(Path.Combine(remote.TempPath, ".go-entry"), Path.GetFileName(candidate));
                 }
+                catch { }
             }
 
             // Ensure the chosen source (and other .cs) have fresh mtime for the window and for stamp/build logic