ttsc 0.30.3 → 0.31.0

package/internal/lspserver/lsp_project_diagnostics_refresh_accumulates_owner_freshness_test.go

@@ -2,8 +2,14 @@ package lspserver
 
 import "testing"
 
-// TestProjectDiagnosticsRefreshAccumulatesOwnerFreshness verifies separate
-// successful refreshes can jointly satisfy one affected-producer generation.
+// TestProjectDiagnosticsRefreshAccumulatesOwnerFreshness verifies separately
+// reported owner successes can jointly satisfy one pending generation. It does
+// not execute the producers that supply those success reports.
+//
+// @evidence contracts/testing.md#behavioral-verification A stale supplied success leaves beta pending; current alpha success leaves beta pending, and current beta success reports completion. An older completion request cannot clear a manually installed newer pending generation or its alpha owner.
+// @evidence contracts/testing.md#independent-expectations Authored generation numbers, alpha/beta membership and literal completion booleans are independent of the actual state-transition helpers. Supplied success sets are inputs, not observations of successful native producers.
+// @evidence contracts/testing.md#distinguishing-cases Stale versus current success, partial versus accumulated completion, and older completion against newer pending state are observed sequentially. Actual concurrent watched events, all-owner mode and the caller's publication are not exercised.
+// @evidence contracts/testing.md#execution-ownership This discoverable Go unit calls the actual Proxy state-transition methods in-process on owned Proxy fields. It uses no substituted operation, native child, temporary project, installed consumer or product host; the newer state is authored directly rather than delivered by a watcher.
 func TestProjectDiagnosticsRefreshAccumulatesOwnerFreshness(t *testing.T) {
   proxy := &Proxy{}
   proxy.projectDiagnosticRefreshPending = true

package/internal/lspserver/lsp_project_diagnostics_refresh_keeps_each_producer_last_good_test.go

@@ -3,17 +3,22 @@ package lspserver
 import "testing"
 
 // TestLSPProjectDiagnosticsRefreshKeepsEachProducerLastGood verifies partial
-// refreshes update only the producers that answered successfully.
+// direct stores replace only their producer's retained diagnostic codes.
 //
 // Project diagnostics are one merged config-URI publication, but their
 // sidecars fail independently. Rebuilding that publication from only the
 // current call's successes would erase a failed producer's prior findings. An
 // empty successful answer is different: it deliberately clears that producer.
 //
-//  1. Seed two producers with successful publications.
-//  2. Refresh only the first and assert the second producer's last-good remains.
-//  3. Clear the second with a successful empty publication.
-//  4. Recover the second and assert manifest-order aggregation is restored.
+//  1. Seed two retained publications through direct stores.
+//  2. Store only the first again and assert the second remains.
+//  3. Store an empty publication for the second, then another nonempty one.
+//  4. Require literal code order at every snapshot stage.
+//
+// @evidence contracts/testing.md#behavioral-verification Actual direct stores and snapshots preserve the untouched second record, clear its codes with an empty publication, and restore its codes after a later store. The literal ordered code lists detect record loss or reordering; no producer query, failure or recovery is executed.
+// @evidence contracts/testing.md#independent-expectations Expected ordered code lists are authored separately from the source's aggregation. The assertion selects diagnostic codes only, so it does not certify URI, message or other publication fields.
+// @evidence contracts/testing.md#distinguishing-cases Initial two records, first-only replacement, second empty replacement and second nonempty replacement are the four direct-store stages. Failure is represented only by omitting a store, not by a failed native command.
+// @evidence contracts/testing.md#execution-ownership The discoverable Go unit directly invokes NativePluginSource.storeProjectDiagnostics and projectDiagnosticsSnapshot with owned publication values. Binary names are opaque record identities: this body starts no child, installs no consumer and creates no temporary project or product host.
 func TestLSPProjectDiagnosticsRefreshKeepsEachProducerLastGood(t *testing.T) {
   first := NativeLSPPluginEntry{Binary: "first", Name: "@ttsc/first"}
   second := NativeLSPPluginEntry{Binary: "second", Name: "@ttsc/second"}

package/internal/lspserver/lsp_project_diagnostics_refreshes_only_input_owners_test.go

@@ -2,17 +2,24 @@ package lspserver
 
 import (
   "bytes"
+  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
 // TestLSPProjectDiagnosticsRefreshesOnlyInputOwners verifies flattened client
-// watch registration does not erase contributor ownership.
+// snapshot ownership can select one failed producer query. This direct unit
+// does not register a client watcher or receive an actual watched-file event.
 //
 //  1. Give two diagnostics-capable producers disjoint exact input snapshots.
 //  2. Resolve the first input's owner from the merged source.
 //  3. Refresh that owner and assert the unrelated producer is never invoked.
+//
+// @evidence contracts/testing.md#behavioral-verification The first supplied .md URI resolves to one literal transport identity; a refresh using that list selects one producer, is incomplete and logs only its name. This observes failed-call selection rather than a successful publication or real watch dispatch.
+// @evidence contracts/testing.md#independent-expectations The owner key, selected count one, complete=false and positive/negative producer names are authored expectations. Both binary lookup failures are checked before native attempts; the owner expectation is not generated by pluginKey.
+// @evidence contracts/testing.md#distinguishing-cases Two producers with disjoint exact inputs separate owner-scoped from broadcast refresh.
+// @evidence contracts/testing.md#execution-ownership The discoverable Go unit directly stores NativePluginSource snapshots and calls its owner matcher and owner-scoped diagnostic refresh. An owned temporary root supplies native URI identity and checked missing binaries reach failed resident/direct starts; there is no substitute query operation, installed consumer or running product host.
 func TestLSPProjectDiagnosticsRefreshesOnlyInputOwners(t *testing.T) {
   root := t.TempDir()
   first := NativeLSPPluginEntry{
@@ -27,6 +34,11 @@ func TestLSPProjectDiagnosticsRefreshesOnlyInputOwners(t *testing.T) {
     ProjectDiagnostics: true,
     ProjectInputs:      true,
   }
+  for _, plugin := range []NativeLSPPluginEntry{first, second} {
+    if path, err := exec.LookPath(plugin.Binary); err == nil {
+      t.Fatalf("missing-binary premise is false: %s", path)
+    }
+  }
   var log bytes.Buffer
   source := &NativePluginSource{
     err:     &log,
@@ -44,7 +56,7 @@ func TestLSPProjectDiagnosticsRefreshesOnlyInputOwners(t *testing.T) {
     },
   })
   owners := source.ProjectInputOwnersForURI(testFileURI(firstInput))
-  if len(owners) != 1 || owners[0] != pluginKey(first) {
+  if len(owners) != 1 || owners[0] != "ttsc-no-such-first-owner-sidecar\x000" {
     t.Fatalf("first input owners = %#v", owners)
   }
 

package/internal/lspserver/lsp_project_diagnostics_resume_preserves_generation_test.go

@@ -11,8 +11,14 @@ func (projectDiagnosticsResumeSource) ProjectDiagnostics() *LSPProjectDiagnostic
 }
 
 // TestResumePendingProjectDiagnosticRefreshDoesNotReviveCompletedWork verifies
-// a save or close advances and rearms pending work atomically, while a refresh
-// completed before that transition remains completed.
+// direct resume advances pending work, while a refresh marked complete before
+// the next direct resume remains complete. Actual save/close dispatch and
+// concurrent atomicity are not exercised.
+//
+// @evidence contracts/testing.md#behavioral-verification Direct resume advances an observed pending generation by one and keeps pending=true; after explicit completion, another direct resume must leave the generation unchanged. Timer rearming, actual save/close routing and concurrent interleavings are not asserted.
+// @evidence contracts/testing.md#independent-expectations Authored arithmetic before+1 and final=after, plus literal pending=true, distinguish progression from revival without reusing a generation calculation helper. Completion receives the actual retained pending generation.
+// @evidence contracts/testing.md#distinguishing-cases Pending work and already completed work have different generation outcomes in the sequential schedule/resume/complete/resume sequence. Dirty-document refusal and concurrent completion are not exercised.
+// @evidence contracts/testing.md#execution-ownership The discoverable Go unit calls actual Proxy scheduling and resume/completion methods with an owned source returning nil diagnostics. Scheduling arms the real timer and asynchronous scheduler; deferred stop clears pending state and closes admission without certifying callback join. No native child, sidecar, temporary project, installed consumer or product host runs and no operation is replaced.
 func TestResumePendingProjectDiagnosticRefreshDoesNotReviveCompletedWork(
   t *testing.T,
 ) {

package/internal/lspserver/lsp_project_diagnostics_translates_relative_client_project_test.go

@@ -7,23 +7,27 @@ import (
 )
 
 // TestLSPProjectDiagnosticsTranslatesRelativeClientProject verifies a project
-// URI is restated in the client's spelling however the client named it.
+// URI uses the supplied client anchor in four direct translation cases.
 //
 // The editor is not required to pass an absolute `--tsconfig`; naming the
-// project relative to the working directory it also passed is the ordinary
-// spelling, and every ttsc CLI accepts it. The translator, however, needs an
+// project relative to a supplied working directory is one input to this unit.
+// The translator needs an
 // absolute path both to compare against the producer's URI and to build a URI
-// from, so a relative spelling used to end the translation and let the sidecar's
-// own spelling reach the editor unchanged — the precise failure this whole
-// translation exists to prevent, surviving in the common case.
+// from, so a relative spelling must not end the translation and let the
+// sidecar's own spelling reach the editor unchanged — the precise failure this
+// direct translation distinguishes from leaving the producer detour unchanged.
 //
-// A client that named no directory either is not a case to decline: this host
-// was started from that directory and inherited it, so its own working
-// directory is the same anchor reached another way.
+// With no supplied directory, the direct operation uses this test process's
+// actual working directory. No launcher inheritance or editor is executed.
 //
 //  1. Resolve a relative project against the directory the client named.
 //  2. Resolve one against the directory the host inherited.
-//  3. Leave an absolute one exactly as the previous behavior did.
+//  3. Translate an absolute one the same way.
+//
+// @evidence contracts/testing.md#behavioral-verification clientProjectURI rewrites a distinct producer detour to the expected client URI for supplied-relative, ambient-cwd-relative and absolute client paths; with no client project it preserves the producer string. This does not observe CLI admission or editor delivery.
+// @evidence contracts/testing.md#independent-expectations Expected anchor paths come from the owned root or os.Getwd plus literal tsconfig.json, separately from clientProjectURI. Input and expected URI serialization share projectInputFileURI, so this is an anchor/rewrite oracle, not an independent URI-encoder oracle. The distinct input/output premise is explicitly checked for the root detour.
+// @evidence contracts/testing.md#distinguishing-cases Supplied directory, omitted directory using actual process cwd, absolute project and absent project are the four cases. The temporary root has a config and src directory; the ambient-cwd case relies on the native ancestor-fallback identity operation rather than creating a real client project there.
+// @evidence contracts/testing.md#execution-ownership The discoverable Go unit calls actual NativePluginSource.clientProjectURI with owned native filesystem inputs and reads process cwd for one case. It installs no consumer, starts no child or host and uses no substitute translation operation; native identity may query owning-directory case flags on Windows.
 func TestLSPProjectDiagnosticsTranslatesRelativeClientProject(t *testing.T) {
   root := t.TempDir()
   if err := os.WriteFile(
@@ -78,7 +82,7 @@ func TestLSPProjectDiagnosticsTranslatesRelativeClientProject(t *testing.T) {
     clientTsconfig: filepath.Join(root, "tsconfig.json"),
   }
   if got := absolute.clientProjectURI(named); got != expected {
-    t.Fatalf("absolute project no longer translated: got %q, want %q", got, expected)
+    t.Fatalf("absolute project not translated: got %q, want %q", got, expected)
   }
 
   // Nothing to translate to, so the producer keeps its own spelling rather than

package/internal/lspserver/lsp_project_input_ownership_resolves_declared_spellings_test.go

@@ -1,30 +1,39 @@
 package lspserver
 
 import (
+  "errors"
   "os"
   "path/filepath"
+  "runtime"
+  "syscall"
   "testing"
 )
 
 // TestLSPProjectInputOwnershipResolvesDeclaredSpellings verifies a declaration
 // is matched against an event through one filesystem identity.
 //
-// The candidate always arrives from an editor URI and is resolved physically,
-// so comparing it against a declaration that was only cleaned lexically can
-// never match wherever the two spellings differ. A Windows short (8.3)
-// component, which the system temporary directory routinely carries, and a
-// symlinked ancestor such as macOS `/var` both produce exactly that, and the
-// contributor that declared the file then receives no refresh at all.
+// An owned directory symlink supplies a spelling distinct from the physical
+// candidate URI. Exact-file and glob ownership must bridge that alias without
+// accepting two adjacent unowned paths. This does not exercise Windows short
+// names, a system macOS alias or an actual contributor refresh.
 //
 //  1. Declare an exact file and a glob through a directory alias.
 //  2. Ask for the owners of the same paths spelled physically.
 //  3. Assert the declaring producer owns both.
 //  4. Assert two adjacent paths one property away are owned by nobody.
+//
+// @evidence contracts/testing.md#behavioral-verification An exact file and a glob declared through a directory alias are owned by the declaring producer when the same paths are spelled physically, and adjacent paths one property away are owned by nobody.
+// @evidence contracts/testing.md#independent-expectations A single literal producer key is required for each positive and zero owners for each negative, independently of pluginKey. The fixture creates the actual alias and files; expected membership does not come from the matcher.
+// @evidence contracts/testing.md#distinguishing-cases Alias and physical spellings must match while near-miss paths must not.
+// @evidence contracts/testing.md#execution-ownership The discoverable Go unit directly stores a snapshot and calls NativePluginSource.ProjectInputOwnersForURI over owned native temporary files and a real directory symlink. Only Windows privilege-not-held skips this alias case; other creation errors fail. No native sidecar starts and no consumer or product host is installed, though Windows identity uses native directory queries.
 func TestLSPProjectInputOwnershipResolvesDeclaredSpellings(t *testing.T) {
   physical := t.TempDir()
   alias := filepath.Join(t.TempDir(), "project")
   if err := os.Symlink(physical, alias); err != nil {
-    t.Skipf("filesystem cannot express a directory alias: %v", err)
+    if runtime.GOOS == "windows" && errors.Is(err, syscall.Errno(1314)) {
+      t.Skipf("Windows symlink privilege is unavailable: %v", err)
+    }
+    t.Fatalf("create owned directory alias: %v", err)
   }
   for _, directory := range []string{
     filepath.Join(physical, "docs"),
@@ -65,7 +74,7 @@ func TestLSPProjectInputOwnershipResolvesDeclaredSpellings(t *testing.T) {
     {label: "glob member", location: matched},
   } {
     owners := source.ProjectInputOwnersForURI(testFileURI(owned.location))
-    if len(owners) != 1 || owners[0] != pluginKey(plugin) {
+    if len(owners) != 1 || owners[0] != "ttsc-no-such-alias-sidecar\x000" {
       t.Fatalf("%s owners = %#v", owned.label, owners)
     }
   }

package/internal/lspserver/lsp_project_input_path_key_windows.go

@@ -22,20 +22,18 @@ type windowsProjectInputPath struct {
 func projectInputPathKey(location string) string {
   normalized := filepath.Clean(projectInputFilesystemPath(location))
   if !filepath.IsAbs(normalized) {
-    return strings.ToLower(filepath.ToSlash(normalized))
+    return filepath.ToSlash(normalized)
   }
   volume := filepath.VolumeName(normalized)
   segments := splitWindowsProjectInputSegments(
     strings.TrimPrefix(normalized, volume),
   )
   current := windowsProjectInputVolumeRoot(volume)
-  sensitive := false
   for index, segment := range segments {
-    if currentSensitivity, ok :=
-      tryQueryProjectInputDirectoryCaseSensitivity(current); ok {
-      sensitive = currentSensitivity
-    }
-    if !sensitive {
+    sensitive, known := tryQueryProjectInputDirectoryCaseSensitivity(current)
+    // A failed native query establishes no permission to merge spellings.
+    // Preserve this segment instead of inheriting another directory's flag.
+    if known && !sensitive {
       segments[index] = strings.ToLower(segments[index])
     }
     current = filepath.Join(current, segment)
@@ -142,16 +140,15 @@ func windowsProjectInputSegments(
   sensitivities := make([]bool, 0, len(segments))
   current := windowsProjectInputVolumeRoot(volume)
   for _, segment := range existing {
-    sensitivities = append(
-      sensitivities,
-      queryProjectInputDirectoryCaseSensitivity(current),
-    )
+    sensitive, known := tryQueryProjectInputDirectoryCaseSensitivity(current)
+    // Membership is invalidation routing, not permission to merge identities.
+    // Unknown capability admits both case spellings so an event cannot be lost.
+    sensitivities = append(sensitivities, known && sensitive)
     current = filepath.Join(current, segment)
   }
   if len(resolved.missing) != 0 {
-    missingSensitivity := queryProjectInputDirectoryCaseSensitivity(
-      resolved.physical,
-    )
+    sensitive, known := tryQueryProjectInputDirectoryCaseSensitivity(resolved.physical)
+    missingSensitivity := known && sensitive
     for range resolved.missing {
       sensitivities = append(sensitivities, missingSensitivity)
     }
@@ -190,8 +187,11 @@ func reverseWindowsProjectInputSegments(segments []string) []string {
 }
 
 func queryProjectInputDirectoryCaseSensitivity(directory string) bool {
-  sensitive, _ := tryQueryProjectInputDirectoryCaseSensitivity(directory)
-  return sensitive
+  sensitive, known := tryQueryProjectInputDirectoryCaseSensitivity(directory)
+  // Unknown capability preserves distinctions in missing-suffix identity keys;
+  // success is required to fold case. Invalidation glob routing uses a separate
+  // conservative match policy in windowsProjectInputSegments.
+  return !known || sensitive
 }
 
 func tryQueryProjectInputDirectoryCaseSensitivity(

package/internal/lspserver/lsp_project_input_path_key_windows_test.go

@@ -10,23 +10,30 @@ import (
   "slices"
   "strings"
   "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/internal/e2etrace"
 )
 
 // TestProjectInputPathKeyRespectsDirectoryCaseSemantics verifies the Go host
 // keeps case-distinct Windows dependencies without splitting ordinary aliases.
 //
-// The original global case fold merged distinct files below an opted-in
-// case-sensitive directory, while preserving every spelling instead split
+// A global case fold would merge distinct files below an opted-in
+// case-sensitive directory, while preserving every spelling would split
 // ordinary NTFS, UNC, and recreated-directory aliases. Identity must instead
 // follow the case semantics of the directory that owns each path segment.
 //
 //  1. Enable case sensitivity on a disposable directory and create two real
 //     dependencies whose paths differ only by case.
-//  2. Prove merged publication and owner matching retain both identities.
-//  3. Prove glob matching and reload containment obey each owning directory.
-//  4. Prove missing suffixes also retain case under an opted-in directory.
-//  5. On an ordinary directory, prove existing and missing aliases converge.
+//  2. Compare stored-input aggregation and owner matching for both identities.
+//  3. Compare glob matching and reload containment at the owning directories.
+//  4. Compare missing suffixes under an opted-in directory.
+//  5. On an ordinary directory, compare existing and missing aliases.
 //  6. Change a live directory's flag and normalize UNC volume aliases.
+//
+// @evidence contracts/testing.md#behavioral-verification Direct stored input aggregation, owner selection, glob and reload predicates distinguish case-sensitive siblings and insensitive aliases. Missing-suffix keys react to a directory flag change and recreation. Literal UNC volume assembly and conditional native extended-UNC/junction cases exercise separate path identities; no client publication or actual plugin reload is observed.
+// @evidence contracts/testing.md#independent-expectations Owned native files and observed directory semantics establish equality/inequality premises. Literal transport owner keys and the literal UNC key do not reuse the key helpers as expected values; shared normalization/digest helpers establish inputs and do not independently certify fingerprint correctness.
+// @evidence contracts/testing.md#distinguishing-cases Existing and missing paths, sensitive siblings, an insensitive child, ordinary aliases, live flag changes, recreation, literal UNC volumes, conditional extended UNC, physical junction ownership, junction creation, deletion and retarget are distinct lanes. Setup-error and unavailable-share skips leave those native lanes unverified on that run.
+// @evidence contracts/testing.md#execution-ownership This Windows-only discoverable Go unit directly calls owning native filesystem identity and stored-input policy operations. Owned fsutil and cmd mklink setup children use CombinedOutput once per invocation and private opt-in observation; setup failures retain existing skips without certifying their cause. No Go build, native plugin sidecar, installed consumer, editor or product host executes.
 func TestProjectInputPathKeyRespectsDirectoryCaseSemantics(t *testing.T) {
   sensitiveRoot := t.TempDir()
   enableProjectInputCaseSensitivity(t, sensitiveRoot)
@@ -80,8 +87,8 @@ func TestProjectInputPathKeyRespectsDirectoryCaseSemantics(t *testing.T) {
   ) {
     t.Fatalf("case-sensitive merged files = %#v", merged.Files)
   }
-  assertProjectInputOwners(t, source, firstInput, []string{pluginKey(first)})
-  assertProjectInputOwners(t, source, secondInput, []string{pluginKey(second)})
+  assertProjectInputOwners(t, source, firstInput, []string{"ttsc-case-sensitive-first\x000"})
+  assertProjectInputOwners(t, source, secondInput, []string{"ttsc-case-sensitive-second\x000"})
   if projectInputPathContains(firstDirectory, secondInput) {
     t.Fatal("case-sensitive sibling was classified as a descendant")
   }
@@ -115,7 +122,7 @@ func TestProjectInputPathKeyRespectsDirectoryCaseSemantics(t *testing.T) {
     t,
     sensitiveGlobSource,
     lowerJSON,
-    []string{pluginKey(first)},
+    []string{"ttsc-case-sensitive-first\x000"},
   )
   assertProjectInputOwners(t, sensitiveGlobSource, upperJSON, nil)
 
@@ -141,7 +148,7 @@ func TestProjectInputPathKeyRespectsDirectoryCaseSemantics(t *testing.T) {
     t,
     mixedGlobSource,
     mixedJSON,
-    []string{pluginKey(first)},
+    []string{"ttsc-case-sensitive-first\x000"},
   )
 
   firstMissing := filepath.Join(firstDirectory, "Missing.json")
@@ -184,7 +191,7 @@ func TestProjectInputPathKeyRespectsDirectoryCaseSemantics(t *testing.T) {
     t,
     ordinaryGlobSource,
     upperJSON,
-    []string{pluginKey(first)},
+    []string{"ttsc-case-sensitive-first\x000"},
   )
 
   ordinarySource := &NativePluginSource{
@@ -301,13 +308,13 @@ func TestProjectInputPathKeyRespectsDirectoryCaseSemantics(t *testing.T) {
       t,
       junctionSource,
       exact,
-      []string{pluginKey(first)},
+      []string{"ttsc-case-sensitive-first\x000"},
     )
     assertProjectInputOwners(
       t,
       junctionSource,
       globbed,
-      []string{pluginKey(first)},
+      []string{"ttsc-case-sensitive-first\x000"},
     )
   })
 
@@ -401,9 +408,12 @@ func enableProjectInputCaseSensitivity(t *testing.T, directory string) {
     directory,
     "enable",
   )
-  if output, err := command.CombinedOutput(); err != nil {
+  observation := e2etrace.BeginCommand(command, "CombinedOutput")
+  output, err := command.CombinedOutput()
+  observation.Result(err)
+  if err != nil {
     t.Skipf(
-      "per-directory case sensitivity is unavailable: %v\n%s",
+      "per-directory case-sensitivity fixture setup failed: %v\n%s",
       err,
       output,
     )
@@ -419,7 +429,10 @@ func disableProjectInputCaseSensitivity(t *testing.T, directory string) {
     directory,
     "disable",
   )
-  if output, err := command.CombinedOutput(); err != nil {
+  observation := e2etrace.BeginCommand(command, "CombinedOutput")
+  output, err := command.CombinedOutput()
+  observation.Result(err)
+  if err != nil {
     t.Fatalf("failed to disable per-directory case sensitivity: %v\n%s", err, output)
   }
 }
@@ -439,8 +452,11 @@ func createProjectInputJunction(
     junction,
     target,
   )
-  if output, err := command.CombinedOutput(); err != nil {
-    t.Skipf("directory junction is unavailable: %v\n%s", err, output)
+  observation := e2etrace.BeginCommand(command, "CombinedOutput")
+  output, err := command.CombinedOutput()
+  observation.Result(err)
+  if err != nil {
+    t.Skipf("directory-junction fixture setup failed: %v\n%s", err, output)
   }
 }
 

package/internal/lspserver/lsp_project_input_registration.go

@@ -351,7 +351,11 @@ func projectInputFileWatchers(
     watcher := newProjectInputFileWatcher(base, pattern)
     unique[projectInputFileWatcherKey(watcher)] = watcher
   }
-  for _, directory := range snapshot.ReloadDirectories {
+  directories := append(
+    append([]string(nil), snapshot.ReloadDirectories...),
+    snapshot.WatchDirectories...,
+  )
+  for _, directory := range directories {
     native := filepath.FromSlash(directory)
     identityBase := nearestExistingProjectInputDirectory(filepath.Dir(native))
     identityPattern := escapeLSPGlobLiteral(

package/internal/lspserver/lsp_project_input_registration_rechecks_selection_baseline_test.go

@@ -21,18 +21,24 @@ func (s *driftingProjectInputRegistrationSource) ProjectInputReloadFingerprintsA
   return s.current
 }
 
-// TestProjectInputRegistrationRechecksSelectionBaseline verifies the client
-// registration response closes the last unobserved startup interval.
+// TestProjectInputRegistrationRechecksSelectionBaseline verifies accepting a
+// pending client registration rechecks supplied selection currentness.
 //
 // Constructor validation happens before initialize and dynamic registration.
 // A reload input can change in that interval without producing a replayable
-// event. Once the client confirms registration, a second baseline check must
-// either cover the earlier change or hand all later changes to the watcher.
+// event. Here an owned source reports stale currentness immediately before the
+// pending response is delivered; actual filesystem drift and later watcher
+// delivery are not exercised.
 //
 //  1. Publish one exact reload-file watcher with a current baseline.
 //  2. Leave the client registration request pending.
 //  3. Mark the selection baseline stale before accepting registration.
 //  4. Prove the proxy notifies the client and requests an expected restart.
+//
+// @evidence contracts/testing.md#behavioral-verification The actual pending-request callback sees the supplied currentness change and emits selection-change method text plus ErrLSPPluginSelectionChanged to the async error channel. No launcher restart or actual filesystem change is observed.
+// @evidence contracts/testing.md#independent-expectations Authored current=true then false controls the source; method text presence uses the maintained method constant and errors.Is uses the declared restart sentinel. These assertions do not independently decode the complete notification payload.
+// @evidence contracts/testing.md#distinguishing-cases One registration remains pending while currentness is changed to false, then an accepted response reaches the recheck. This unit does not cover a current baseline, a rejected response or actual concurrent watch delivery.
+// @evidence contracts/testing.md#execution-ownership The discoverable Go unit executes actual Proxy registration/response operations using an owned interface implementation, bytes buffer and temporary root used as path data. No sidecar, installed consumer, native child, product host or real editor runs; no foreign method is replaced.
 func TestProjectInputRegistrationRechecksSelectionBaseline(t *testing.T) {
   root := t.TempDir()
   source := &driftingProjectInputRegistrationSource{

package/internal/lspserver/lsp_project_input_registration_reconciles_rejected_pending_request_test.go

@@ -30,6 +30,11 @@ func (s *mutableProjectInputRegistrationSource) ProjectInputs() LSPProjectInputS
 //  3. Register D, leave cleanup of C pending, then publish E and reject cleanup.
 //  4. Assert E registers while the rejected cleanup remains deferred.
 //  5. Publish F and assert retained cleanup completes once before F replaces E.
+//
+// @evidence contracts/testing.md#behavioral-verification The supplied A-through-F response sequence preserves active A after rejecting B, advances desired C, defers rejected cleanup of C, drains retained C then D before accepting F, and ends with no pending or stale IDs. The registration sequence counter must equal six; actual editor watcher installation and exact wire-send counts are not observed.
+// @evidence contracts/testing.md#independent-expectations Pending booleans, ordered stale-ID membership, captured active-ID preservation and literal registration count six follow from the authored sequence. Desired signature expectations reuse projectInputWatchRegistrationForSnapshot, so independent correctness of signature construction is not certified.
+// @evidence contracts/testing.md#distinguishing-cases Rejected replacement retains the last active registration, whereas rejected cleanup retains stale work and allows a newer registration. Later desired-state change releases blocked cleanup before replacement; accepted responses remove each recorded stale ID. Native failures, concurrent editor events and notification payload contents are outside these assertions.
+// @evidence contracts/testing.md#execution-ownership This discoverable Go unit executes actual Proxy reconciliation and pending-response callbacks with an owned mutable source, bytes buffer and temporary root used as path data. The helper requires exactly one pending request and submits its actual ID; no native child, sidecar, installed consumer, product host or real editor runs and no foreign method is replaced.
 func TestProjectInputRegistrationReconcilesRejectedPendingRequest(
   t *testing.T,
 ) {

package/internal/lspserver/lsp_project_input_registration_shapes_patterns_test.go

@@ -6,18 +6,24 @@ import (
 )
 
 // TestProjectInputRegistrationShapesRelativePatterns verifies exact paths and
-// glob populations become deterministic LSP RelativePatterns without treating
+// glob populations become deduplicated LSP RelativePatterns without treating
 // literal filename metacharacters as wildcards.
 //
 // Reload directories need two registrations: immediate children carry
-// topology changes, while the exact directory identity carries deletion and
-// replacement when a child-rooted watcher can no longer observe the object.
+// topology attention, while the exact directory identity represents deletion
+// and replacement attention. This unit checks descriptors, not actual watcher
+// delivery after native replacement.
 //
 //  1. Declare duplicate exact files, portable globs, and one reload directory.
 //  2. Build and index the deduplicated relative-pattern registrations.
 //  3. Assert literals are escaped while portable wildcard segments survive.
 //  4. Assert reload-directory identity and immediate-child patterns both exist.
 //  5. Assert drive and UNC file URIs preserve their authority and escaping.
+//
+// @evidence contracts/testing.md#behavioral-verification Actual watcher descriptors contain five deduplicated pattern strings with literal metacharacters escaped, wildcard segments preserved, and reload-directory identity plus child patterns. Two independent URI literals check drive escaping and UNC authority. Iteration order, complete base URIs and actual client matching are not asserted.
+// @evidence contracts/testing.md#independent-expectations Five pattern strings, count five and two complete URI strings are authored literals. Watcher kind is compared with the declared all-events constant; base URI checks require nonempty values for the exact and JSON-glob lanes rather than independent full URI equality.
+// @evidence contracts/testing.md#distinguishing-cases Duplicate exact/reload-file entries, literal star/question/bracket/brace filename characters, wildcard segments with literal bracket/brace segments, two reload-directory patterns, drive paths and UNC paths are covered. The test does not certify descriptor ordering or native watcher delivery.
+// @evidence contracts/testing.md#execution-ownership This discoverable Go unit calls actual projectInputFileWatchers and projectInputFileURI in-process using an owned temporary root and authored path data. No substituted operation, native child, sidecar, installed consumer or product host runs; the filename with Windows-reserved characters is not materialized on disk.
 func TestProjectInputRegistrationShapesRelativePatterns(t *testing.T) {
   root := t.TempDir()
   exact := filepath.Join(

package/internal/lspserver/lsp_project_input_watchers_anchor_missing_paths_test.go

@@ -8,13 +8,18 @@ import (
 // TestProjectInputWatchersAnchorMissingPaths verifies dynamic registrations use
 // an existing ancestor while retaining the missing path in the glob.
 //
-// Editors cannot reliably root a RelativePattern at a directory that does not
-// exist yet. Anchoring at the physical project lets the registration observe
-// later directory creation without broadening beyond the declared pattern.
+// The owned root exists while neither nested directory has been created. The
+// descriptors preserve the declared suffixes under that root; this test does
+// not install them in an editor or observe later directory creation.
 //
 //  1. Declare one exact file and one glob under missing nested directories.
 //  2. Build the client watcher registrations before either directory exists.
 //  3. Assert both use the project URI and preserve their missing path segments.
+//
+// @evidence contracts/testing.md#behavioral-verification Registrations for an exact file and a glob under missing nested directories use the project URI as base and preserve the missing path segments in the pattern.
+// @evidence contracts/testing.md#independent-expectations Count two and both full pattern strings are authored literals. Expected base URI is produced by the same projectInputFileURI helper used by the watcher implementation, so this equality checks root selection without independently certifying URI encoding.
+// @evidence contracts/testing.md#distinguishing-cases An exact file and a wildcard population have distinct missing nested suffixes under an existing owned root. Existing nested anchors, future creation delivery and editor matching are outside this test.
+// @evidence contracts/testing.md#execution-ownership The discoverable Go unit directly calls actual projectInputFileWatchers against an owned fresh temporary root and absent nested path data. No substitute operation, sidecar, native child, installed consumer, editor or product host runs.
 func TestProjectInputWatchersAnchorMissingPaths(t *testing.T) {
   root := t.TempDir()
   watchers := projectInputFileWatchers(LSPProjectInputSnapshot{