fix: close pack-only filesystem health gaps

Author: jstar0

internal/cli/fold.go

@@ -1,8 +1,11 @@
 package cli
 
 import (
+	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
+	"os"
 	"path/filepath"
 
 	"github.com/samekind/codexfold/internal/codex"
@@ -134,13 +137,7 @@ func newDoctorCommand() *cobra.Command {
 				return err
 			}
 			storeDir = resolveFoldStore(home, storeDir)
-			var reader fold.ObjectReader
-			resolver, packErr := pack.Open(storeDir, pack.OpenOptions{CacheBytes: -1})
-			if packErr == nil {
-				defer resolver.Close()
-				reader = resolver
-			}
-			result, err := fold.DoctorWithOptions(command.Context(), storeDir, fold.DoctorOptions{Reader: reader})
+			result, err := doctorFoldStore(command.Context(), storeDir)
 			if err != nil {
 				return err
 			}
@@ -157,6 +154,21 @@ func newDoctorCommand() *cobra.Command {
 	return command
 }
 
+func doctorFoldStore(ctx context.Context, storeDir string) (fold.DoctorResult, error) {
+	resolver, err := pack.Open(storeDir, pack.OpenOptions{CacheBytes: -1})
+	if err == nil {
+		defer resolver.Close()
+		return fold.DoctorWithOptions(ctx, storeDir, fold.DoctorOptions{Reader: resolver})
+	}
+	current := filepath.Join(filepath.Clean(storeDir), "packs", "CURRENT")
+	if _, currentErr := os.Lstat(current); errors.Is(currentErr, os.ErrNotExist) {
+		return fold.Doctor(ctx, storeDir)
+	} else if currentErr != nil {
+		return fold.DoctorResult{}, currentErr
+	}
+	return fold.DoctorResult{}, fmt.Errorf("open current pack for fold verification: %w", err)
+}
+
 func newGCCommand() *cobra.Command {
 	var codexHome string
 	var storeDir string

internal/cli/fs.go

@@ -602,6 +602,11 @@ func newFSServeCommand() *cobra.Command {
 			if nativeFSKitSocket == "" {
 				nativeFSKitSocket = defaultNativeFSKitSocket(home, nativeFSKitResource)
 			}
+			if frontend == "native-fskit" {
+				if err := validateNativeFSKitSocketPath(nativeFSKitSocket); err != nil {
+					return err
+				}
+			}
 			result := FSServeResult{MountPoint: mount, ManagedSessions: len(states), Frontend: frontend, DryRun: !apply}
 			if frontend == "native-fskit" {
 				result.ResourcePath = nativeFSKitResource
@@ -910,6 +915,13 @@ func defaultNativeFSKitSocket(home string, resourcePath string) string {
 	return filepath.Join("/private/tmp", fmt.Sprintf("codexfold-fskit-%d-%s.sock", os.Getuid(), hex.EncodeToString(digest[:4])))
 }
 
+func validateNativeFSKitSocketPath(path string) error {
+	if len(path) >= 104 {
+		return errors.New("native FSKit Unix socket path exceeds the macOS limit; choose a shorter resource path")
+	}
+	return nil
+}
+
 func syncCanonicalRetirement(
 	store string,
 	home string,
@@ -1808,7 +1820,7 @@ func requireStorageHealth(ctx context.Context, store string) error {
 	if packReport.IssueCount != 0 {
 		return fmt.Errorf("pack doctor reported %d issues", packReport.IssueCount)
 	}
-	foldReport, err := fold.Doctor(ctx, store)
+	foldReport, err := doctorFoldStore(ctx, store)
 	if err != nil {
 		return err
 	}
@@ -1932,7 +1944,7 @@ func fsDoctor(ctx context.Context, home string, store string, mount string, defi
 			return nil
 		}},
 		{Component: fsctl.ComponentManifest, Run: func(ctx context.Context) error {
-			report, err := fold.Doctor(ctx, store)
+			report, err := doctorFoldStore(ctx, store)
 			if err != nil {
 				return err
 			}

internal/cli/fs_enroll.go

@@ -12,7 +12,6 @@ import (
 
 	"github.com/samekind/codexfold/internal/codex"
 	"github.com/samekind/codexfold/internal/enroll"
-	"github.com/samekind/codexfold/internal/fold"
 	"github.com/samekind/codexfold/internal/fsctl"
 	"github.com/samekind/codexfold/internal/mountfs"
 	"github.com/samekind/codexfold/internal/pack"
@@ -261,7 +260,7 @@ func buildEnrollmentPlan(ctx context.Context, flags enrollmentFlags) (enroll.Pla
 }
 
 func requireEnrollmentStorageHealth(ctx context.Context, store string) error {
-	foldReport, err := fold.Doctor(ctx, store)
+	foldReport, err := doctorFoldStore(ctx, store)
 	if err != nil {
 		return err
 	}

internal/cli/fs_service.go

@@ -346,6 +346,11 @@ func newFSServiceInstallCommand() *cobra.Command {
 				}
 				fskitResource = service.DefaultFSKitResourcePath(userHome)
 			}
+			if frontend == "native-fskit" {
+				if err := validateNativeFSKitSocketPath(defaultNativeFSKitSocket(home, fskitResource)); err != nil {
+					return err
+				}
+			}
 			if frontend == "native-fskit" && apply {
 				within, err := filepath.Rel(appTransaction.AppGroupPath(), filepath.Clean(fskitResource))
 				if err != nil || within == ".." || strings.HasPrefix(within, ".."+string(filepath.Separator)) {

internal/cli/fs_test.go

@@ -54,6 +54,53 @@ func TestRootExposesPackAndFilesystemCommands(t *testing.T) {
 	}
 }
 
+func TestDoctorFoldStoreVerifiesPackOnlyManifests(t *testing.T) {
+	storeDir := t.TempDir()
+	source := filepath.Join(t.TempDir(), "rollout.jsonl")
+	data := bytes.Repeat([]byte("{\"pack_only\":true}\n"), 256)
+	if err := os.WriteFile(source, data, 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := fold.Fold(context.Background(), fold.Session{ID: "session", RolloutPath: source, Archived: true}, fold.FoldOptions{StoreDir: storeDir, Apply: true}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := pack.Build(context.Background(), storeDir, pack.BuildOptions{}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := pack.RetireLoose(context.Background(), storeDir, pack.RetireLooseOptions{Apply: true}); err != nil {
+		t.Fatal(err)
+	}
+	report, err := doctorFoldStore(context.Background(), storeDir)
+	if err != nil || report.IssueCount != 0 || report.VerifiedManifestCount != 1 {
+		t.Fatalf("pack-only fold doctor: report=%#v err=%v", report, err)
+	}
+}
+
+func TestDoctorFoldStoreDoesNotMaskBrokenCurrentPackWithLooseObjects(t *testing.T) {
+	storeDir := t.TempDir()
+	source := filepath.Join(t.TempDir(), "rollout.jsonl")
+	if err := os.WriteFile(source, []byte("{\"pack\":\"must remain authoritative\"}\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := fold.Fold(context.Background(), fold.Session{ID: "session", RolloutPath: source, Archived: true}, fold.FoldOptions{StoreDir: storeDir, Apply: true}); err != nil {
+		t.Fatal(err)
+	}
+	result, err := pack.Build(context.Background(), storeDir, pack.BuildOptions{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	packFiles, err := filepath.Glob(filepath.Join(storeDir, "packs", result.Generation, "*.pack"))
+	if err != nil || len(packFiles) == 0 {
+		t.Fatalf("locate current pack: files=%v err=%v", packFiles, err)
+	}
+	if err := os.Remove(packFiles[0]); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := doctorFoldStore(context.Background(), storeDir); err == nil || !strings.Contains(err.Error(), "open current pack") {
+		t.Fatalf("broken current pack error = %v", err)
+	}
+}
+
 func TestRetainCanonicalSnapshotBudgetRejectsBeforeCreatingSnapshot(t *testing.T) {
 	root := t.TempDir()
 	store := filepath.Join(root, "store")
@@ -424,6 +471,25 @@ func TestFSServiceInstallRendersNativeFSKitDaemonAndSupervisor(t *testing.T) {
 	}
 }
 
+func TestFSServiceInstallRejectsNativeFSKitResourceWithOverlongSocketPath(t *testing.T) {
+	if runtime.GOOS != "darwin" {
+		t.Skip("native FSKit services are macOS-only")
+	}
+	home, storeDir, _ := fsFixture(t, true)
+	resource := filepath.Join(string(filepath.Separator), strings.Repeat("a", 110))
+	root := NewRootCommand()
+	root.SetOut(&bytes.Buffer{})
+	root.SetErr(&bytes.Buffer{})
+	root.SetArgs([]string{
+		"fs", "service", "install", "--frontend", "native-fskit",
+		"--codex-home", home, "--store", storeDir, "--fskit-resource", resource,
+	})
+	err := root.Execute()
+	if err == nil || !strings.Contains(err.Error(), "Unix socket path exceeds the macOS limit") {
+		t.Fatalf("overlong native FSKit resource error = %v", err)
+	}
+}
+
 func TestFSServiceInstallCustomLabelUsesCustomDefinitionPath(t *testing.T) {
 	if runtime.GOOS != "darwin" {
 		t.Skip("custom LaunchAgent labels are macOS-only")