fix: make macOS CI pass for compact search and reranker tracing

Checkpoint libSQL WAL before Close so immutable search can see documents.
Lock the Darwin exec-trace thread and detach with addr=1 to avoid SIGTRAP.

Amp-Thread-ID: https://ampcode.com/threads/T-01a07399-82c4-76c8-b33d-34b2c89b219b
Co-authored-by: Amp <amp@ampcode.com>

Author: XiaoConstantine

pkg/index/index.go

@@ -738,6 +738,9 @@ func (idx *Indexer) Index(ctx context.Context) error {
 	if debugLevel >= util.DebugSummary {
 		stats.PrintSummary()
 	}
+	if err := idx.Checkpoint(ctx); err != nil {
+		return fmt.Errorf("checkpoint index: %w", err)
+	}
 	if err := writeRepoMetadata(idx.repoDir, idx.rootPath); err != nil {
 		return fmt.Errorf("finalize index metadata: %w", err)
 	}

pkg/rerank/supervisor.go

@@ -288,6 +288,9 @@ func runConstrainedReranker(args []string) error {
 	if len(args) < 3 || args[1] != "--" {
 		return fmt.Errorf("invalid constrained reranker command")
 	}
+	// Darwin PT_TRACE_ME is thread-local. Stay on this OS thread through
+	// syscall.Exec so the traced exec stop is delivered to the supervisor.
+	runtime.LockOSThread()
 	identity := os.NewFile(3, "reranker-identity")
 	if identity == nil {
 		return fmt.Errorf("reranker identity descriptor is unavailable")
@@ -947,10 +950,9 @@ func runRerankerSupervisor(cfg supervisorConfig) error {
 	if err := armRunnerExec(identities.supervisor); err != nil {
 		return abortBeforeHandle(err)
 	}
-	if err := authorizeRunnerExec(identities.supervisor); err != nil {
-		return abortBeforeHandle(err)
-	}
-	state, releaseExec, reaped, err := waitForStoppedRerankerExec(cmd.Process.Pid, expectedDevice, expectedInode)
+	state, releaseExec, reaped, err := waitForStoppedRerankerExec(cmd.Process.Pid, expectedDevice, expectedInode, func() error {
+		return authorizeRunnerExec(identities.supervisor)
+	})
 	childReaped = reaped
 	if err != nil {
 		return abortBeforeHandle(err)

pkg/rerank/supervisor_peer_darwin.go

@@ -70,6 +70,8 @@ func enableRerankerExecTrace() error {
 	// PT_TRACE_ME stops this process at each following exec before the new
 	// image can execute user code. The supervisor refreshes the guardian's
 	// audit-token handle while the configured image is stopped.
+	// Darwin applies this to the calling thread; runConstrainedReranker
+	// locks the OS thread before arming and keeps it through exec.
 	//nolint:staticcheck // x/sys exposes Darwin ptrace constants but no trace-me wrapper.
 	_, _, errno := unix.Syscall6(unix.SYS_PTRACE, unix.PT_TRACE_ME, 0, 0, 0, 0, 0)
 	if errno != 0 {
@@ -78,8 +80,14 @@ func enableRerankerExecTrace() error {
 	return nil
 }
 
-func waitForStoppedRerankerExec(pid int, expectedDevice, expectedInode uint64) (rerankerPIDState, func() error, bool, error) {
+func waitForStoppedRerankerExec(pid int, expectedDevice, expectedInode uint64, authorize func() error) (rerankerPIDState, func() error, bool, error) {
 	deadline := time.Now().Add(supervisorSetupTimeout)
+	if authorize != nil {
+		if err := authorize(); err != nil {
+			_ = syscall.Kill(pid, syscall.SIGKILL)
+			return rerankerPIDState{}, nil, false, err
+		}
+	}
 	for {
 		remaining := time.Until(deadline)
 		if remaining <= 0 {
@@ -96,7 +104,7 @@ func waitForStoppedRerankerExec(pid int, expectedDevice, expectedInode uint64) (
 		state, inspectErr := inspectRerankerProcess(pid)
 		if inspectErr == nil && state.ExecutableDevice == expectedDevice && state.ExecutableInode == expectedInode {
 			return state, func() error {
-				if err := unix.PtraceDetach(pid); err != nil {
+				if err := detachDarwinTrace(pid); err != nil {
 					return fmt.Errorf("detach constrained reranker exec trace: %w", err)
 				}
 				return nil
@@ -151,8 +159,18 @@ func waitForDarwinTraceEvent(pid int, timeout time.Duration) (syscall.WaitStatus
 }
 
 func continueDarwinTrace(pid int) error {
+	return ptraceDarwin(unix.PT_CONTINUE, pid)
+}
+
+func detachDarwinTrace(pid int) error {
+	// x/sys's PtraceDetach passes addr=0. Darwin treats that like a null PC
+	// on detach and delivers the exec-stop SIGTRAP as a fatal trace/BPT trap.
+	return ptraceDarwin(unix.PT_DETACH, pid)
+}
+
+func ptraceDarwin(request, pid int) error {
 	//nolint:staticcheck // x/sys exposes attach/detach but no Darwin PT_CONTINUE wrapper.
-	_, _, errno := unix.Syscall6(unix.SYS_PTRACE, unix.PT_CONTINUE, uintptr(pid), 1, 0, 0, 0)
+	_, _, errno := unix.Syscall6(unix.SYS_PTRACE, uintptr(request), uintptr(pid), 1, 0, 0, 0)
 	if errno != 0 {
 		return errno
 	}

pkg/rerank/supervisor_peer_linux.go

@@ -44,7 +44,12 @@ func enableRerankerExecTrace() error {
 	return nil
 }
 
-func waitForStoppedRerankerExec(pid int, expectedDevice, expectedInode uint64) (rerankerPIDState, func() error, bool, error) {
+func waitForStoppedRerankerExec(pid int, expectedDevice, expectedInode uint64, authorize func() error) (rerankerPIDState, func() error, bool, error) {
+	if authorize != nil {
+		if err := authorize(); err != nil {
+			return rerankerPIDState{}, nil, false, err
+		}
+	}
 	state, err := waitForRerankerExec(pid, expectedDevice, expectedInode)
 	return state, func() error { return nil }, false, err
 }

pkg/store/libsql.go

@@ -1291,9 +1291,23 @@ func (s *LibSQLStore) ExportFileEmbeddings(ctx context.Context) ([]string, [][]f
 	return filePaths, vecs, nil
 }
 
-// Close closes the database.
+// Close checkpoints WAL into the main DB, then closes the database.
+//
+// Search opens the same file with modernc sqlite and immutable=1, which does
+// not read leftover WAL. Compact metadata writes must be visible after Close.
 func (s *LibSQLStore) Close() error {
-	return s.db.Close()
+	var checkpointErr error
+	if !s.readOnly {
+		checkpointErr = s.Checkpoint(context.Background())
+	}
+	closeErr := s.db.Close()
+	if checkpointErr != nil {
+		if closeErr != nil {
+			return fmt.Errorf("%w; close: %v", checkpointErr, closeErr)
+		}
+		return checkpointErr
+	}
+	return closeErr
 }
 
 // Checkpoint flushes WAL data into the main DB and truncates sidecar growth.

pkg/store/libsql_test.go

@@ -699,6 +699,41 @@ func TestLibSQLStore_FTSUpdateRemovesOldTerms(t *testing.T) {
 	}
 }
 
+func TestLibSQLStore_CloseMakesMetadataVisibleToImmutableSearch(t *testing.T) {
+	dir := t.TempDir()
+	dbPath := filepath.Join(dir, "index.db")
+	s, err := OpenLibSQL(dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ctx := context.Background()
+	doc := &Document{
+		ID: "visible.go:chunk_1", FilePath: "visible.go", Content: "func visible() {}",
+		StartLine: 1, EndLine: 1,
+	}
+	if err := s.StoreMetadataBatch(ctx, []*Document{doc}); err != nil {
+		_ = s.Close()
+		t.Fatal(err)
+	}
+	if err := s.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	metadata, err := OpenSQLiteMetadata(dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = metadata.Close() }()
+	got, err := metadata.GetChunksByFilePath(ctx, doc.FilePath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got) != 1 || got[0].ID != doc.ID || got[0].Content != doc.Content {
+		t.Fatalf("immutable metadata after Close = %+v, want %s", got, doc.ID)
+	}
+}
+
 func TestLibSQLStore_GetChunksForColBERT_IncludesCompactMetadataRows(t *testing.T) {
 	dir := t.TempDir()
 	s, err := OpenLibSQL(filepath.Join(dir, "test.db"))