fix(remotecache): defer store close, add Push test, add freshness TTL

- Replace defer-in-loop with eager close in repo sync (defer inside a
  for loop leaks connections until function return)
- Add FreshFor TTL to Cache (default 30s) — Ensure() skips pull when
  last pull is within the window, FreshFor=0 preserves always-pull
- Add TestPush: full round-trip integration test (clone → insert → push
  → re-clone → verify data)
- Add TestEnsureFreshFor: validates TTL skip and FreshFor=0 bypass
- Add concurrency doc comment to OpenStore

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: mrmaxsteel

cmd/bd/repo.go

@@ -274,9 +274,7 @@ Also triggers Dolt push/pull if a remote is configured.`,
 				}
 
 				issues, err := remoteStore.SearchIssues(ctx, "", types.IssueFilter{})
-				if closeErr := remoteStore.Close(); closeErr != nil {
-					fmt.Fprintf(os.Stderr, "Warning: failed to close remote store for %s: %v\n", repoPath, closeErr)
-				}
+				_ = remoteStore.Close() // close eagerly — defer in a loop would leak connections
 				if err != nil {
 					fmt.Fprintf(os.Stderr, "Warning: failed to read issues from %s: %v\n", repoPath, err)
 					continue

internal/remotecache/cache.go

@@ -26,7 +26,8 @@ type StoreOpener func(ctx context.Context, beadsDir string) (storage.DoltStorage
 // Cache manages local clones of remote Dolt databases.
 // Each remote URL maps to a directory under Dir named by CacheKey(url).
 type Cache struct {
-	Dir string // e.g., ~/.cache/beads/remotes
+	Dir      string        // e.g., ~/.cache/beads/remotes
+	FreshFor time.Duration // skip pull if last pull was within this duration; 0 means always pull
 }
 
 // CacheMeta stores metadata about a cached remote clone.
@@ -36,14 +37,18 @@ type CacheMeta struct {
 	LastPush  int64  `json:"last_push_ns"`
 }
 
+// defaultFreshFor is the default TTL for cached clones. Ensure() skips
+// pulling when the last pull was within this duration.
+const defaultFreshFor = 30 * time.Second
+
 // DefaultCache returns a Cache using the XDG-conventional cache directory.
 func DefaultCache() (*Cache, error) {
 	cacheDir, err := os.UserCacheDir()
 	if err != nil {
 		return nil, fmt.Errorf("failed to determine cache directory: %w", err)
 	}
 	dir := filepath.Join(cacheDir, "beads", "remotes")
-	return &Cache{Dir: dir}, nil
+	return &Cache{Dir: dir, FreshFor: defaultFreshFor}, nil
 }
 
 // entryDir returns the cache entry directory for a remote URL.
@@ -93,7 +98,16 @@ func (c *Cache) Ensure(ctx context.Context, remoteURL string) (string, error) {
 
 	target := c.cloneTarget(remoteURL)
 	if c.doltExists(target) {
-		// Warm start: pull
+		// Warm start: skip pull if the cache is still fresh
+		if c.FreshFor > 0 {
+			meta := c.readMeta(remoteURL)
+			age := time.Since(time.Unix(0, meta.LastPull))
+			if age < c.FreshFor {
+				debug.Logf("remotecache: skipping pull for %s (%.1fs old, fresh for %.0fs)\n",
+					remoteURL, age.Seconds(), c.FreshFor.Seconds())
+				return entry, nil
+			}
+		}
 		if err := c.doltPull(ctx, target); err != nil {
 			return "", fmt.Errorf("dolt pull failed for %s: %w", remoteURL, err)
 		}
@@ -144,6 +158,11 @@ func (c *Cache) Push(ctx context.Context, remoteURL string) error {
 // OpenStore opens a DoltStorage from the cached clone using the provided
 // StoreOpener. The cache entry directory is used as the beads directory.
 // The caller is responsible for calling Close() on the returned store.
+//
+// Note: OpenStore does not acquire a cache lock. The caller must ensure
+// no concurrent Ensure() or Push() is running against the same remoteURL,
+// as those modify the underlying dolt database. This is safe for single-
+// process CLI use but not for concurrent multi-process access.
 func (c *Cache) OpenStore(ctx context.Context, remoteURL string, opener StoreOpener) (storage.DoltStorage, error) {
 	entry := c.entryDir(remoteURL)
 	if !c.doltExists(c.cloneTarget(remoteURL)) {

internal/remotecache/cache_test.go

@@ -5,7 +5,9 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strings"
 	"testing"
+	"time"
 )
 
 // skipIfNoDolt skips the test if the dolt CLI is not installed.
@@ -166,6 +168,110 @@ func TestEvict(t *testing.T) {
 	}
 }
 
+func TestPush(t *testing.T) {
+	skipIfNoDolt(t)
+	ctx := context.Background()
+
+	tmpDir := t.TempDir()
+	remoteURL := initDoltRemote(t, filepath.Join(tmpDir, "remote"))
+
+	cache := &Cache{Dir: filepath.Join(tmpDir, "cache")}
+
+	// Clone the remote
+	if _, err := cache.Ensure(ctx, remoteURL); err != nil {
+		t.Fatalf("Ensure failed: %v", err)
+	}
+
+	// Make a local change in the cached clone
+	target := cache.cloneTarget(remoteURL)
+	cmd := exec.Command("dolt", "sql", "-q", "INSERT INTO test_table VALUES (1, 'pushed')")
+	cmd.Dir = target
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("insert failed: %v\n%s", err, out)
+	}
+
+	cmd = exec.Command("dolt", "add", ".")
+	cmd.Dir = target
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("dolt add failed: %v\n%s", err, out)
+	}
+
+	cmd = exec.Command("dolt", "commit", "-m", "add row")
+	cmd.Dir = target
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("dolt commit failed: %v\n%s", err, out)
+	}
+
+	// Push back to remote
+	if err := cache.Push(ctx, remoteURL); err != nil {
+		t.Fatalf("Push failed: %v", err)
+	}
+
+	// Verify push timestamp was recorded
+	meta := cache.readMeta(remoteURL)
+	if meta.LastPush == 0 {
+		t.Error("meta.LastPush should be set after Push")
+	}
+
+	// Verify the data made it to the remote by cloning into a fresh dir
+	verifyDir := filepath.Join(tmpDir, "verify")
+	cmd = exec.Command("dolt", "clone", remoteURL, verifyDir)
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("verification clone failed: %v\n%s", err, out)
+	}
+
+	cmd = exec.Command("dolt", "sql", "-q", "SELECT name FROM test_table WHERE id = 1", "-r", "csv")
+	cmd.Dir = verifyDir
+	out, err := cmd.Output()
+	if err != nil {
+		t.Fatalf("verification query failed: %v", err)
+	}
+	if !strings.Contains(string(out), "pushed") {
+		t.Errorf("expected 'pushed' in verification output, got: %s", out)
+	}
+}
+
+func TestEnsureFreshFor(t *testing.T) {
+	skipIfNoDolt(t)
+	ctx := context.Background()
+
+	tmpDir := t.TempDir()
+	remoteURL := initDoltRemote(t, filepath.Join(tmpDir, "remote"))
+
+	cache := &Cache{
+		Dir:      filepath.Join(tmpDir, "cache"),
+		FreshFor: 1 * time.Hour, // very long TTL so second call skips pull
+	}
+
+	// Cold start (always clones)
+	if _, err := cache.Ensure(ctx, remoteURL); err != nil {
+		t.Fatalf("Ensure (cold) failed: %v", err)
+	}
+
+	firstMeta := cache.readMeta(remoteURL)
+
+	// Second call should skip pull because of FreshFor
+	if _, err := cache.Ensure(ctx, remoteURL); err != nil {
+		t.Fatalf("Ensure (warm, fresh) failed: %v", err)
+	}
+
+	secondMeta := cache.readMeta(remoteURL)
+	if secondMeta.LastPull != firstMeta.LastPull {
+		t.Error("LastPull should NOT update when cache is still fresh")
+	}
+
+	// With FreshFor=0, should always pull
+	cache.FreshFor = 0
+	if _, err := cache.Ensure(ctx, remoteURL); err != nil {
+		t.Fatalf("Ensure (warm, FreshFor=0) failed: %v", err)
+	}
+
+	thirdMeta := cache.readMeta(remoteURL)
+	if thirdMeta.LastPull <= firstMeta.LastPull {
+		t.Error("LastPull should update when FreshFor=0")
+	}
+}
+
 func TestDefaultCache(t *testing.T) {
 	cache, err := DefaultCache()
 	if err != nil {