cellstore: stop at a dangling link, walk the missing suffix once

Review fixes: only components that are truly absent (Lstat says so) are kept
as written; a link whose target is missing keeps the absolute spelling, so a
chat's dangling work/ link named through an alias stays foreign. The missing
suffix is collected in one pass and the existing ancestor resolved once. The
through-a-file test runs on Windows too.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: AbirAbbas

internal/cellstore/canonical_tree_test.go

@@ -3,7 +3,6 @@ package cellstore
 import (
 	"os"
 	"path/filepath"
-	"runtime"
 	"testing"
 )
 
@@ -52,9 +51,6 @@ func TestCanonicalTreeResolvesAncestorOfMissingWorkspace(t *testing.T) {
 // A path through a file is not a missing folder: it keeps its absolute
 // spelling rather than being resolved past the file.
 func TestCanonicalTreeKeepsAPathThroughAFile(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("Windows reports a path through a file as a missing path")
-	}
 	real, link := linkedRoot(t)
 	if err := os.WriteFile(filepath.Join(real, "file"), []byte("x"), 0o600); err != nil {
 		t.Fatal(err)
@@ -91,3 +87,29 @@ func TestForeignFolderKeepsMissingWorkUnderSymlinkedChat(t *testing.T) {
 		t.Fatal("a folder outside the chat is not called foreign")
 	}
 }
+
+// A link whose target is missing is not a missing folder: a path through it
+// keeps its spelled, absolute form, so a chat's work/ that is a dangling link
+// to somewhere else stays foreign when the chat is named through an alias.
+func TestCanonicalTreeDoesNotResolvePastADanglingLink(t *testing.T) {
+	real, link := linkedRoot(t)
+	chat := filepath.Join(real, "chat")
+	if err := os.MkdirAll(filepath.Join(chat, filepath.FromSlash(filepath.Dir(OwnFolderPath))), 0o700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(chat, filepath.FromSlash(OwnFolderPath)), []byte("own\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(filepath.Join(t.TempDir(), "absent"), filepath.Join(chat, "work")); err != nil {
+		t.Skipf("this filesystem cannot make a symbolic link: %v", err)
+	}
+	for _, spelled := range []string{filepath.Join(link, "chat", "work"), filepath.Join(link, "chat", "work", "deeper")} {
+		if got := canonicalTree(spelled); got != spelled {
+			t.Errorf("a path through a dangling link: got %q, want it unchanged %q", got, spelled)
+		}
+	}
+	useHome(t, t.TempDir())
+	if !ForeignFolder(filepath.Join(link, "chat"), filepath.Join(link, "chat", "work")) {
+		t.Error("a dangling work/ link named through the alias is not called foreign")
+	}
+}

internal/cellstore/engine.go

@@ -10,6 +10,7 @@ import (
 	"os/user"
 	"path/filepath"
 	"runtime"
+	"slices"
 	"strings"
 	"time"
 
@@ -414,13 +415,14 @@ func (e Engine) target(c cell.Cell) Target {
 // whichever spelling named it: macOS reaches /tmp and /var through links, and a
 // home or project folder can sit under a linked folder too.
 //
-// A TREE THAT DOES NOT EXIST YET STILL RESOLVES ITS ANCESTORS. Its longest
+// A tree that does not exist yet still resolves its ancestors. Its longest
 // existing ancestor is resolved and the missing rest is kept as written. Were
-// the lexical spelling returned instead, the same folder would change spelling
-// the moment it was created: a binding recorded before creation would read as
+// the spelled path returned instead, the same folder would change spelling the
+// moment it was created: a binding recorded before creation would read as
 // another folder after it, and a chat's own absent work/ would compare as
-// outside the chat's resolved folder. Any other failure keeps the absolute
-// spelling, as before.
+// outside the chat's resolved folder. Only components that are truly absent
+// are kept as written; a link whose target is missing is not a missing folder,
+// so a path through one keeps its absolute spelling, as does any other failure.
 func canonicalTree(tree string) string {
 	absolute, err := filepath.Abs(tree)
 	if err != nil {
@@ -433,9 +435,26 @@ func canonicalTree(tree string) string {
 	if !errors.Is(err, os.ErrNotExist) {
 		return absolute
 	}
-	parent := filepath.Dir(absolute)
-	if parent == absolute {
+	existing, missing := absolute, []string(nil)
+	for {
+		_, err := os.Lstat(existing)
+		if err == nil {
+			break
+		}
+		parent := filepath.Dir(existing)
+		if !errors.Is(err, os.ErrNotExist) || parent == existing {
+			return absolute
+		}
+		missing = append(missing, filepath.Base(existing))
+		existing = parent
+	}
+	if len(missing) == 0 {
+		return absolute
+	}
+	resolved, err = filepath.EvalSymlinks(existing)
+	if err != nil {
 		return absolute
 	}
-	return filepath.Join(canonicalTree(parent), filepath.Base(absolute))
+	slices.Reverse(missing)
+	return filepath.Join(append([]string{resolved}, missing...)...)
 }