ttsc 0.30.3 → 0.31.0

package/cmd/ttscgraph/serve_adopts_a_republished_set_over_the_shard_protocol_test.go

@@ -0,0 +1,122 @@
+package main
+
+import (
+  "bytes"
+  "encoding/json"
+  "fmt"
+  "path/filepath"
+  "testing"
+)
+
+// TestServeAdoptsARepublishedSetOverTheShardProtocol verifies artifact replacement reaches the negotiated shard response.
+//
+// Legacy dumps and shard publications share invalidation but use different
+// projection and response shapes. A shard refresh must also replace the source
+// shard whose citation names the changed document address.
+//
+// 1. Negotiate version-one shards and publish the Pricing artifact.
+// 2. Name the replacement Discounts set in the next request.
+// 3. Require rebuild shards with only the replacement artifact and citing source.
+//
+// @evidence contracts/testing.md#behavioral-verification Actual NDJSON shard publication initially includes the pricing artifact and one pricing doc_ref in src/index.ts. Replacement publishes Discounts without Pricing and re-emits src/index.ts without a pricing or discounts doc_ref: its unchanged authored tag still names the withdrawn pricing address.
+// @evidence contracts/testing.md#independent-expectations Literal pricing and discounts addresses identify the old and new artifact facts. The authored source cites that address, so retaining its old shard would retain a stale edge; the replacement must include src/index.ts.
+// @evidence contracts/testing.md#distinguishing-cases Initial negotiated shards contrast a republished set requiring rebuild, old-node removal, new-node retention and re-emission of the citing source. The separate legacy case owns full-dump response semantics.
+// @evidence contracts/testing.md#execution-ownership TestServeAdoptsARepublishedSetOverTheShardProtocol is a Go source-unit entry. serveSnapshotRequests performs actual NDJSON decoding and resident lifecycle through the source publisher; prepared projection consumes explicit empty ignore membership. The owning operations stay in this test process, without installing a consumer or building or starting a native product binary. The separate worktree E2E owns real Git acquisition.
+func TestServeAdoptsARepublishedSetOverTheShardProtocol(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": { "target": "ES2022", "module": "commonjs", "strict": true },
+  "include": ["src"]
+}`)
+  // The declaration cites the artifact, so the edge to it lives in this
+  // source's own shard while the artifact node lands in the metadata shard.
+  // Both have to move together: a snapshot that replaced the artifact and left
+  // this shard alone would leave the client holding an edge into an address
+  // nothing publishes any more.
+  writeGraphFile(t, filepath.Join(root, "src", "index.ts"),
+    "/** @evidence docs/sale.md#pricing States the rule. */\nexport class Priced {}\n")
+  published := t.TempDir()
+  first := filepath.Join(published, "first.json")
+  second := filepath.Join(published, "second.json")
+  writeArtifactSet(t, first, "docs/sale.md#pricing", "Pricing")
+  writeArtifactSet(t, second, "docs/sale.md#discounts", "Discounts")
+
+  var output bytes.Buffer
+  code := serveSourceSnapshotsWithArtifacts(
+    bytes.NewReader([]byte(fmt.Sprintf(
+      "{\"id\":1,\"graphSnapshotVersion\":%d,\"artifacts\":%s}\n{\"id\":2,\"graphSnapshotVersion\":%d,\"artifacts\":%s}\n",
+      graphSnapshotProtocolVersion,
+      mustJSONString(t, first),
+      graphSnapshotProtocolVersion,
+      mustJSONString(t, second),
+    ))),
+    &output,
+    root,
+    "tsconfig.json",
+    nil,
+  )
+  if code != 0 {
+    t.Fatalf("serveSnapshotsWithArtifacts exited %d: %s", code, output.String())
+  }
+
+  decoder := json.NewDecoder(&output)
+  var initial serveResponse
+  var republished serveResponse
+  if err := decoder.Decode(&initial); err != nil {
+    t.Fatal(err)
+  }
+  if err := decoder.Decode(&republished); err != nil {
+    t.Fatal(err)
+  }
+  if initial.Snapshot == nil {
+    t.Fatalf("the shard protocol was not negotiated: %#v", initial)
+  }
+  if !shardsCarryArtifact(initial.Snapshot, "docs/sale.md#pricing") {
+    t.Fatal("the initial shard snapshot does not carry the artifact its request named")
+  }
+  initialSources, initialCitations := 0, 0
+  for _, upsert := range initial.Snapshot.Upserts {
+    if upsert.Shard.Source == nil || upsert.Shard.Source.File != "src/index.ts" {
+      continue
+    }
+    initialSources++
+    for _, edge := range upsert.Shard.Edges {
+      if edge.Kind == "doc_ref" && edge.To == "docs/sale.md#pricing" {
+        initialCitations++
+      }
+    }
+  }
+  if initialSources != 1 || initialCitations != 1 {
+    t.Fatalf("initial source/citation counts = %d/%d, want 1/1", initialSources, initialCitations)
+  }
+  if republished.Mode != serveModeRebuild || republished.Snapshot == nil {
+    t.Fatalf("a republished set over the shard protocol answered %#v", republished)
+  }
+  if !shardsCarryArtifact(republished.Snapshot, "docs/sale.md#discounts") {
+    t.Fatal("the republished shard snapshot does not carry the artifact that replaced the old one")
+  }
+  if shardsCarryArtifact(republished.Snapshot, "docs/sale.md#pricing") {
+    t.Fatal("the republished shard snapshot still carries the withdrawn artifact")
+  }
+  // The citing source's shard has to come with it, whichever projection the
+  // session chose. Its edges name the address that just moved, so a client left
+  // holding the previous version of this shard holds a dangling one.
+  if !shardsCarrySource(republished.Snapshot, "src/index.ts") {
+    t.Fatal("the shard owning the citing declaration was not re-emitted, so its edge to the withdrawn address survives in the client")
+  }
+  republishedSources := 0
+  for _, upsert := range republished.Snapshot.Upserts {
+    if upsert.Shard.Source == nil || upsert.Shard.Source.File != "src/index.ts" {
+      continue
+    }
+    republishedSources++
+    for _, edge := range upsert.Shard.Edges {
+      if edge.Kind == "doc_ref" && (edge.To == "docs/sale.md#pricing" || edge.To == "docs/sale.md#discounts") {
+        t.Errorf("unchanged pricing tag retained or acquired an unresolved citation edge: %+v", edge)
+      }
+    }
+  }
+  if republishedSources != 1 {
+    t.Fatalf("republished source count = %d, want 1", republishedSources)
+  }
+}

package/cmd/ttscgraph/serve_answers_a_project_that_implements_its_own_ambient_declaration_test.go

@@ -12,17 +12,19 @@ import (
 // assembly succeeds for a project that declares an ambient global in its own
 // `.d.ts` and assigns the implementation elsewhere.
 //
-// Shard partition indexes edge sources by non-external node, and external nodes
-// live in a non-source shard that may own no edges. An edge leaving one is
-// therefore not a wrong fact but an unassemblable snapshot: the session refused
-// the whole transaction with "edge source node is absent from shard facts", so
-// every request failed before it ran while `dump`, which applies no such check,
-// still emitted the graph.
+// Source shard partitioning requires an owner for each outgoing edge. This
+// fixture combines an owned ambient declaration and an implementation elsewhere,
+// exercising assembly rather than certifying every underlying graph fact.
 //
 //  1. Serve a project whose `src/globals.d.ts` declares `var patched` and whose
 //     `src/index.ts` assigns an arrow function to it.
 //  2. Request one negotiated shard snapshot.
 //  3. Assert the response carries a complete transaction and no error.
+//
+// @evidence contracts/testing.md#behavioral-verification Verifies shard assembly succeeds for a project that declares an ambient global in its own `.d.ts` and assigns the implementation elsewhere.
+// @evidence contracts/testing.md#independent-expectations The supported initial-transaction invariant requires no error, initial mode, changed=true, no legacy dump, a nonempty manifest, exactly one upsert per manifest key with its declared digest, and no deletes. Duplicate keys, unknown upserts or mismatched digests violate this independently stated correspondence; equality does not authenticate digest bytes or complete graph semantics. The authored ambient/global assignment supplies the assembly boundary input, without claiming a newly executed historical reproduction.
+// @evidence contracts/testing.md#distinguishing-cases Serve a project whose `src/globals.d.ts` declares `var patched` and whose `src/index.ts` assigns an arrow function to it; Request one negotiated shard snapshot; Assert the response carries a complete transaction and no error.
+// @evidence contracts/testing.md#execution-ownership TestServeAnswersAProjectThatImplementsItsOwnAmbientDeclaration is a Go source-unit entry. serveSnapshotRequests performs actual NDJSON decoding and resident lifecycle through the source publisher; prepared projection consumes explicit empty ignore membership. The owning operations stay in this test process, without installing a consumer or building or starting a native product binary. The separate worktree E2E owns real Git acquisition.
 func TestServeAnswersAProjectThatImplementsItsOwnAmbientDeclaration(t *testing.T) {
   root := t.TempDir()
   writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{
@@ -42,7 +44,7 @@ patched = (message: string): void => {
 
   input := strings.NewReader("{\"id\":1,\"graphSnapshotVersion\":1}\n")
   var output bytes.Buffer
-  if code := serveSnapshots(input, &output, root, "tsconfig.json"); code != 0 {
+  if code := serveSourceSnapshots(input, &output, root, "tsconfig.json"); code != 0 {
     t.Fatalf("serveSnapshots exited %d: %s", code, output.String())
   }
 
@@ -66,4 +68,30 @@ patched = (message: string): void => {
       len(initial.Snapshot.Deletes),
     )
   }
+  manifestDigests := make(map[string]string, len(initial.Snapshot.Manifest))
+  for _, entry := range initial.Snapshot.Manifest {
+    if entry.Key == "" || entry.Digest == "" {
+      t.Fatalf("initial manifest entry lacks a key or digest: %+v", entry)
+    }
+    if _, duplicate := manifestDigests[entry.Key]; duplicate {
+      t.Fatalf("duplicate initial manifest key: %s", entry.Key)
+    }
+    manifestDigests[entry.Key] = entry.Digest
+  }
+  seenUpserts := make(map[string]bool, len(initial.Snapshot.Upserts))
+  for _, upsert := range initial.Snapshot.Upserts {
+    expectedDigest, exists := manifestDigests[upsert.Shard.Key]
+    if !exists || upsert.Digest != expectedDigest {
+      t.Fatalf("initial upsert does not match its manifest entry: key=%s digest=%s", upsert.Shard.Key, upsert.Digest)
+    }
+    if seenUpserts[upsert.Shard.Key] {
+      t.Fatalf("duplicate initial upsert key: %s", upsert.Shard.Key)
+    }
+    seenUpserts[upsert.Shard.Key] = true
+  }
+  for key := range manifestDigests {
+    if !seenUpserts[key] {
+      t.Fatalf("initial manifest key has no upsert: %s", key)
+    }
+  }
 }

package/cmd/ttscgraph/serve_early_error_encode_failure_is_observable_test.go

@@ -19,6 +19,11 @@ func (rejectedServeWriter) Write([]byte) (int, error) {
 //  1. Reject protocol negotiation before a graph session is constructed.
 //  2. Fail the response writer and require a nonzero server result.
 //  3. Require the stderr cause while forbidding successful phase rows.
+//
+// @evidence contracts/testing.md#behavioral-verification TestServeEarlyErrorEncodeFailureIsObservable proves a rejected early error response fails the stream without claiming that an unencoded response ran.
+// @evidence contracts/testing.md#independent-expectations The expected outcome follows from the serve contract that an unencodable response must fail the stream: the writer always errors, so the test requires a nonzero exit, the stderr text 'write serve response: synthetic response write failure', and no ttscgraph-phase rows even though tracing is enabled. A server that swallowed the write error or logged timings for an unsent response fails.
+// @evidence contracts/testing.md#distinguishing-cases Reject protocol negotiation before a graph session is constructed; Fail the response writer and require a nonzero server result; Require the stderr cause while forbidding successful phase rows.
+// @evidence contracts/testing.md#execution-ownership TestServeEarlyErrorEncodeFailureIsObservable is a Go source-unit entry. It calls serveSnapshots in-process with an unsupported graphSnapshotVersion, so the protocol rejection is encoded before any compiler session or Git acquisition happens; the writer is a failing stub, so nothing is installed, built or launched.
 func TestServeEarlyErrorEncodeFailureIsObservable(t *testing.T) {
   root := graphSessionFixture(t)
   oldStderr := stderr

package/cmd/ttscgraph/serve_error_response_still_names_its_mode_test.go

@@ -12,10 +12,10 @@ import (
 // TestServeErrorResponseStillNamesItsMode verifies a failed snapshot answers
 // with a mode and a protocol version rather than dropping them.
 //
-// This is the negative twin of the successful snapshot. Mode used to be
-// omitempty, so it vanished on exactly the path where a consumer most needs to
-// say what happened: the error path serves no dump and set no mode, leaving
-// "what did the compiler do" unanswerable and the field unrelied-upon. A field
+// This is the negative twin of the successful snapshot. An omitempty mode would
+// vanish on exactly the path where a consumer most needs to say what happened:
+// the error path serves no dump, leaving "what did the compiler do"
+// unanswerable and the field unrelied-upon. A field
 // that is present only when things go well is not a field a consumer can branch
 // on.
 //
@@ -23,6 +23,11 @@ import (
 //  2. Assert the response carries the error, and mode is the error mode.
 //  3. Assert the protocol version still rides it, so the client can read it at
 //     all.
+//
+// @evidence contracts/testing.md#behavioral-verification Verifies a failed snapshot answers with a mode and a protocol version rather than dropping them.
+// @evidence contracts/testing.md#independent-expectations The expected id (7), mode error, protocol version and the three wire keys (mode, protocolVersion, capabilities) come from the serve envelope contract and are asserted both on the typed value and on the raw JSON keys, so an omitempty regression on mode fails even though the Go field is set. The invalid tsconfig text is a literal fixture.
+// @evidence contracts/testing.md#distinguishing-cases Serve a project whose tsconfig is invalid, so the session cannot be built; Assert the response carries the error, and mode is the error mode; Assert the protocol version still rides it, so the client can read it at all.
+// @evidence contracts/testing.md#execution-ownership TestServeErrorResponseStillNamesItsMode is a Go source-unit entry. It calls serveSnapshots in-process over a fixture whose tsconfig.json is invalid, so session creation fails before projection or Git acquisition; nothing is installed, built or launched.
 func TestServeErrorResponseStillNamesItsMode(t *testing.T) {
   root := graphSessionFixture(t)
   if err := os.WriteFile(filepath.Join(root, "tsconfig.json"), []byte("{ invalid"), 0o644); err != nil {
@@ -60,7 +65,7 @@ func TestServeErrorResponseStillNamesItsMode(t *testing.T) {
   }
 
   // The wire keys, not the Go fields: mode must survive serialization, which is
-  // the whole regression — omitempty dropped it there and nowhere else.
+  // where an omitempty tag would drop it and nowhere else.
   var raw map[string]any
   if err := json.Unmarshal(line, &raw); err != nil {
     t.Fatal(err)

package/cmd/ttscgraph/serve_git_ignore_projection_test.go

@@ -0,0 +1,150 @@
+package main
+
+import (
+  "bytes"
+  "encoding/json"
+  "os/exec"
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/internal/e2etrace"
+  "github.com/samchon/ttsc/packages/ttsc/internal/graph"
+)
+
+// TestGitIgnoreMembershipFlowsThroughNativeProjectionAdapters verifies actual
+// Git membership reaches the default dump and resident publication adapters.
+//
+// One real worktree contains an ignored source with a space in its path and an
+// authored peer. The source remains a graph endpoint while its ignored flag is
+// preserved through full, partial, unchanged and repaired generations.
+//
+//  1. Initialize an owned Git worktree whose .gitignore names one source; the
+//     adapters then obtain real NUL-delimited membership through git check-ignore.
+//  2. Run the default dump and resident adapters over the same source corpus.
+//  3. Edit, restore and repair the project, checking every published membership.
+//
+// @evidence contracts/testing.md#behavioral-verification Real git init prepares an owned worktree and production git check-ignore evaluates membership. The default dump and initial legacy snapshot contain Generated with ignored=true and Visible with ignored=false. Resident full and incremental requests publish, while unchanged requests publish no snapshot; checkNodes inspects the committed store after each successful resident transition. Invalid config requires an error, no snapshot and changed=false before exact-config recovery.
+// @evidence contracts/testing.md#independent-expectations The literal ignore rule selects Generated and excludes Visible. Restoring the exact prior config bytes preserves the committed program, so recovery is unchanged; private body edits require incremental publication.
+// @evidence contracts/testing.md#distinguishing-cases A space-bearing ignored source, nonignored dependency, full and partial publications, byte restoration, unchanged requests and invalid-config recovery distinguish acquisition and publication paths.
+// @evidence contracts/testing.md#execution-ownership This Go unit test calls run for the dump verb and newGraphSession for the resident adapters in the Go test process and actually spawns Git: the test's own git init uses CombinedOutput and the production check-ignore call uses Output, so both children are joined. The three sequential subtests restore the swapped output streams or close their session before fixture cleanup, and a failed subtest does not stop the others. It does not invoke a built product CLI.
+func TestGitIgnoreMembershipFlowsThroughNativeProjectionAdapters(t *testing.T) {
+  root := t.TempDir()
+  config := `{"compilerOptions":{"target":"ES2022","module":"commonjs","strict":true},"include":["src"]}`
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), config)
+  writeGraphFile(t, filepath.Join(root, ".gitignore"), "src/generated code.ts\n")
+  source := "export function Generated(): number { return 1; }\n"
+  generated := filepath.Join(root, "src", "generated code.ts")
+  writeGraphFile(t, generated, source)
+  visible := filepath.Join(root, "src", "visible.ts")
+  visibleSource := "import { Generated } from './generated code'; export function Visible(): number { return Generated(); }\n"
+  writeGraphFile(t, visible, visibleSource)
+  command := exec.Command("git", "init", "--quiet", root)
+  // Observer owner: graph-membership-fixture-git-init. The original method runs
+  // once; tracing records actual Cmd state and call bounds, not descendant joins.
+  observation := e2etrace.BeginCommand(command, "CombinedOutput")
+  output, initErr := command.CombinedOutput()
+  observation.Result(initErr)
+  if initErr != nil {
+    t.Fatalf("real Git worktree precondition: %v: %s", initErr, output)
+  }
+
+  checkNodes := func(t *testing.T, stage string, nodes []graph.DumpNode) {
+    t.Helper()
+    found := map[string]bool{}
+    for _, node := range nodes {
+      if node.Name != "Generated" && node.Name != "Visible" {
+        continue
+      }
+      found[node.Name] = true
+      if node.Ignored != (node.Name == "Generated") {
+        t.Errorf("%s %s ignored=%v", stage, node.Name, node.Ignored)
+      }
+    }
+    for _, name := range []string{"Generated", "Visible"} {
+      if !found[name] {
+        t.Errorf("%s missing %s", stage, name)
+      }
+    }
+  }
+  t.Run("default dump dispatch", func(t *testing.T) {
+    var output, errors bytes.Buffer
+    priorOut, priorErr := stdout, stderr
+    defer func() { stdout, stderr = priorOut, priorErr }()
+    stdout, stderr = &output, &errors
+    code := run([]string{"dump", "--cwd", root, "--tsconfig", "tsconfig.json"})
+    if code != 0 {
+      t.Fatalf("default dump status=%d: %s", code, errors.String())
+    }
+    var dump graph.Dump
+    if err := json.Unmarshal(output.Bytes(), &dump); err != nil {
+      t.Fatal(err)
+    }
+    checkNodes(t, "default dump", dump.Nodes)
+  })
+
+  t.Run("resident shards", func(t *testing.T) {
+    session, err := newGraphSession(root, "tsconfig.json")
+    if err != nil {
+      t.Fatal(err)
+    }
+    defer session.Close()
+    verify := func(stage, expectedMode string) {
+      t.Helper()
+      snapshot, mode, changed, err := session.SnapshotShards()
+      if err != nil {
+        t.Fatalf("%s: %v", stage, err)
+      }
+      if mode != expectedMode {
+        t.Errorf("%s mode=%s want=%s", stage, mode, expectedMode)
+      }
+      if expectedMode == serveModeUnchanged {
+        if snapshot != nil || changed {
+          t.Errorf("%s unexpectedly published", stage)
+        }
+      } else if snapshot == nil || !changed {
+        t.Errorf("%s failed to publish", stage)
+      }
+      if session.graphStore == nil {
+        t.Fatal(stage + " has no committed store for dependent transitions")
+      }
+      var nodes []graph.DumpNode
+      for _, shard := range session.graphStore.shards {
+        nodes = append(nodes, shard.shard.Nodes...)
+      }
+      checkNodes(t, stage, nodes)
+    }
+    verify("full", serveModeInitial)
+    verify("unchanged", serveModeUnchanged)
+    writeGraphFile(t, generated, "export function Generated(): number { return 2; }\n")
+    verify("partial", serveModeIncremental)
+    writeGraphFile(t, generated, source)
+    verify("restored", serveModeIncremental)
+    verify("restored unchanged", serveModeUnchanged)
+    writeGraphFile(t, filepath.Join(root, "tsconfig.json"), "{")
+    if snapshot, _, changed, err := session.SnapshotShards(); err == nil || snapshot != nil || changed {
+      t.Error("invalid config did not fail closed")
+    }
+    writeGraphFile(t, filepath.Join(root, "tsconfig.json"), config)
+    verify("recovered prior config", serveModeUnchanged)
+    writeGraphFile(t, visible, "import { Generated } from './generated code'; export function Visible(): number { return Generated() + 1; }\n")
+    verify("post-recovery edit", serveModeIncremental)
+  })
+
+  // Independent adapters keep executing after another phase's failure. Restore
+  // their common corpus even when a resident dependent transition stopped early.
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), config)
+  writeGraphFile(t, generated, source)
+  writeGraphFile(t, visible, visibleSource)
+  t.Run("legacy resident dump", func(t *testing.T) {
+    legacy, err := newGraphSession(root, "tsconfig.json")
+    if err != nil {
+      t.Fatal(err)
+    }
+    defer legacy.Close()
+    full, mode, changed, err := legacy.Snapshot()
+    if err != nil || full == nil || mode != serveModeInitial || !changed {
+      t.Fatalf("legacy default: mode=%s changed=%v error=%v", mode, changed, err)
+    }
+    checkNodes(t, "legacy default", full.Nodes)
+  })
+}

package/cmd/ttscgraph/serve_keeps_a_startup_set_a_client_never_mentions_test.go

@@ -0,0 +1,69 @@
+package main
+
+import (
+  "bytes"
+  "encoding/json"
+  "slices"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/internal/graph"
+)
+
+// TestServeKeepsAStartupSetAClientNeverMentions verifies an omitted artifact field preserves the startup set.
+//
+// Omission carries no replacement instruction, whereas an explicit empty path
+// withdraws artifacts. The resident source operation must retain its supplied
+// startup set across both initial and unchanged requests.
+//
+// 1. Supply the literal startup artifact to the resident operation.
+// 2. Send two NDJSON requests without an artifacts field.
+// 3. Require the initial node, unchanged second response and retained claim.
+//
+// @evidence contracts/testing.md#behavioral-verification serveSnapshotRequests retains the supplied startup artifact when both requests omit artifacts, returning its node initially and preserving the artifactNodes claim on unchanged.
+// @evidence contracts/testing.md#independent-expectations The explicitly supplied docs/sale.md#pricing startup entry is the literal fact. Requests with no artifacts key state no withdrawal, so the first response must carry the node, the second must be unchanged with Changed false, and both envelopes must keep the artifactNodes capability; treating silence as withdrawal would fail the second request.
+// @evidence contracts/testing.md#distinguishing-cases Initial versus repeated field omission distinguishes preserving startup state from explicit empty-path withdrawal in the republish case. This source case supplies the startup value directly and does not parse a CLI flag.
+// @evidence contracts/testing.md#execution-ownership TestServeKeepsAStartupSetAClientNeverMentions is a Go source-unit entry. serveSnapshotRequests performs actual NDJSON decoding and resident lifecycle through the source publisher; prepared projection consumes explicit empty ignore membership. The owning operations stay in this test process, without installing a consumer or building or starting a native product binary. The separate worktree E2E owns real Git acquisition.
+func TestServeKeepsAStartupSetAClientNeverMentions(t *testing.T) {
+  root := graphSessionFixture(t)
+
+  var output bytes.Buffer
+  code := serveSourceSnapshotsWithArtifacts(
+    bytes.NewReader([]byte("{\"id\":1}\n{\"id\":2}\n")),
+    &output,
+    root,
+    "tsconfig.json",
+    []graph.Artifact{{
+      Address:  "docs/sale.md#pricing",
+      File:     "docs/sale.md",
+      Kind:     "markdown_section",
+      Line:     7,
+      Readable: "Pricing",
+    }},
+  )
+  if code != 0 {
+    t.Fatalf("serveSnapshotsWithArtifacts exited %d: %s", code, output.String())
+  }
+
+  decoder := json.NewDecoder(&output)
+  var initial serveResponse
+  var second serveResponse
+  if err := decoder.Decode(&initial); err != nil {
+    t.Fatal(err)
+  }
+  if err := decoder.Decode(&second); err != nil {
+    t.Fatal(err)
+  }
+  if !dumpCarriesArtifact(initial.Dump, "docs/sale.md#pricing") {
+    t.Fatalf("the startup set is absent from the initial dump: %#v", initial)
+  }
+  // The second request is where a silence-means-withdrawal reading would show:
+  // the first is the initial projection and carries the set either way.
+  if second.Mode != serveModeUnchanged || second.Changed {
+    t.Fatalf("a request naming no artifacts was treated as a change: %#v", second)
+  }
+  for _, response := range []serveResponse{initial, second} {
+    if !slices.Contains(response.Capabilities, string(graph.CapabilityArtifactNodes)) {
+      t.Fatalf("a session holding the startup set stopped claiming it: %v", response.Capabilities)
+    }
+  }
+}

package/cmd/ttscgraph/serve_object_members_refresh_without_identity_collisions_test.go

@@ -0,0 +1,82 @@
+package main
+
+import (
+  "path/filepath"
+  "testing"
+)
+
+// TestServeObjectMembersRefreshWithoutIdentityCollisions verifies resident
+// object-member facts track edits through aliases and barrel re-exports.
+//
+//  1. Load an object API and a consumer through a re-exporting module.
+//  2. Rename, remove and add its method and caller in the same resident session.
+//  3. Require current identities and calls, no stale methods, and equivalence
+//     with a full projection at every committed generation.
+//
+// @evidence contracts/testing.md#behavioral-verification Actual shard snapshots publish the current object method/caller call and remove obsolete members through successive source edits; committed facts match the full builder.
+// @evidence contracts/testing.md#independent-expectations Literal method names and caller bodies prescribe each node and call independently. Differential full projection checks transaction consistency but cannot establish extraction semantics by itself.
+// @evidence contracts/testing.md#distinguishing-cases Initial, renamed, removed and newly added method states retain alias and barrel resolution. Every transition rejects the other literal method names as stale endpoints.
+// @evidence contracts/testing.md#execution-ownership Owns one temporary project and resident graphSession, invokes actual preparation/projection in the Go test process, and closes it without building or launching a product binary.
+func TestServeObjectMembersRefreshWithoutIdentityCollisions(t *testing.T) {
+  root := t.TempDir()
+  writeGraphFile(t, filepath.Join(root, "tsconfig.json"), `{"compilerOptions":{"target":"ES2022","module":"commonjs","strict":true},"include":["src"]}`)
+  writeGraphFile(t, filepath.Join(root, "src", "barrel.ts"), "export { api } from './api';\n")
+  var session *graphSession
+  for _, method := range []string{"create", "replace", "", "added"} {
+    api := "export const api = {};\n"
+    caller := "export function caller(): number { return 0; }\n"
+    if method != "" {
+      api = "export const api = { " + method + "(): number { return 1; } };\n"
+      caller = "import { api as alias } from './barrel';\nexport function caller(): number { return alias." + method + "(); }\n"
+    }
+    writeGraphFile(t, filepath.Join(root, "src", "api.ts"), api)
+    writeGraphFile(t, filepath.Join(root, "src", "use.ts"), caller)
+    if session == nil {
+      var err error
+      session, err = newGraphSession(root, "tsconfig.json")
+      if err != nil {
+        t.Fatal(err)
+      }
+      defer session.Close()
+    }
+    snapshot, _, _, err := snapshotGraphShardState(session)
+    if err != nil || snapshot == nil {
+      t.Fatalf("snapshot for %q: %v", method, err)
+    }
+    assertServeShardFactsMatchFullDump(t, session)
+    dump, err := projectGraphDump(session)
+    if err != nil {
+      t.Fatal(err)
+    }
+    var target, from string
+    for _, node := range dump.Nodes {
+      qualified := node.QualifiedName
+      if qualified == "" {
+        qualified = node.Name
+      }
+      for _, other := range []string{"create", "replace", "added"} {
+        if qualified == "api."+other {
+          if other != method {
+            t.Errorf("stale method %q in state %q", other, method)
+          }
+          target = node.ID
+        }
+      }
+      if qualified == "caller" {
+        from = node.ID
+      }
+    }
+    if method == "" {
+      continue
+    }
+    found := false
+    for _, edge := range dump.Edges {
+      if edge.From == from && edge.To == target && edge.Kind == "calls" {
+        found = true
+      }
+    }
+    if target == "" || from == "" || !found {
+      t.Errorf("missing current caller->api.%s", method)
+    }
+  }
+}

package/cmd/ttscgraph/serve_phase_trace_accounts_for_load_failure_test.go

@@ -6,12 +6,18 @@ import (
   "testing"
 )
 
-// TestServePhaseTraceAccountsForLoadFailure proves addressed requests retain a
-// complete timing record even when no resident compiler session can be built.
+// TestServePhaseTraceAccountsForLoadFailure checks the five phase labels and
+// duration prefixes on an addressed load error. It does not validate timing
+// values or exclude every possible payload fragment.
 //
 //  1. Request a missing tsconfig with phase tracing enabled.
 //  2. Require a normal addressed error response rather than process failure.
-//  3. Require all five payload-free phases under mode=error.
+//  3. Require all five phase prefixes under mode=error and reject the named fixture fragments.
+//
+// @evidence contracts/testing.md#behavioral-verification The addressed missing-config response carries id 23 and mode error, and the captured diagnostic contains each named phase with its duration prefix. The test rejects the root path, missing-config name fragment and JSON object opener; it does not authenticate duration values or all possible disclosures.
+// @evidence contracts/testing.md#independent-expectations The literal phase-trace contract supplies owner=producer request=23 mode=error phase=<name> durationMs= and the five phase names. Independent forbidden fragments are the fixture root, missing-tsconfig and the object opener { followed by a quotation mark. Missing prefixes or these disclosures fail; duplicate rows, numeric duration accuracy and other payload fragments are not asserted.
+// @evidence contracts/testing.md#distinguishing-cases Request a missing tsconfig with phase tracing enabled; require an addressed error response with server status zero; require the five phase prefixes under mode=error and reject the named fixture fragments.
+// @evidence contracts/testing.md#execution-ownership TestServePhaseTraceAccountsForLoadFailure is a Go source-unit entry. It calls serveSnapshots in-process with a missing tsconfig name so session creation fails before any projection or Git acquisition; stderr is captured, and nothing is installed, built or launched.
 func TestServePhaseTraceAccountsForLoadFailure(t *testing.T) {
   root := graphSessionFixture(t)
   request := "{\"id\":23,\"graphSnapshotVersion\":1}\n"

package/cmd/ttscgraph/serve_phase_trace_is_opt_in_and_payload_free_test.go

@@ -6,12 +6,18 @@ import (
   "testing"
 )
 
-// TestServePhaseTraceIsOptInAndPayloadFree proves the benchmark diagnostic is
-// disabled by default and exposes timings without project or request content.
+// TestServePhaseTraceIsOptInAndPayloadFree checks an empty opt-in value versus 1,
+// the five phase prefixes, and absence of the named fixture fragments. Numeric
+// timing accuracy and other possible disclosures are outside its assertions.
 //
-//  1. Run the same native shard request with tracing disabled and enabled.
+//  1. Run the same shard request through the source owner with tracing disabled and enabled.
 //  2. Capture only the server diagnostic stream, not the response payload.
-//  3. Require the five named phases and reject fixture paths and JSON bodies.
+//  3. Require the five named phase prefixes and reject the root, request field and object opener.
+//
+// @evidence contracts/testing.md#behavioral-verification An empty trace variable leaves stderr empty; value 1 emits the five named initial-request phase prefixes. The captured trace must omit the root path, graphSnapshotVersion and the JSON object opener. This observes those selected fragments rather than all project or request information.
+// @evidence contracts/testing.md#independent-expectations The opt-in contract supplies empty stderr for the empty value and literal owner=producer request=17 mode=initial phase=<name> durationMs= prefixes for value 1. Independently authored forbidden fragments are the root path, graphSnapshotVersion and the object opener { followed by a quotation mark. Duplicate rows and numeric duration accuracy are not asserted.
+// @evidence contracts/testing.md#distinguishing-cases Run the same shard request through the source owner with the trace value empty and 1; capture the server diagnostic stream; require five named phase prefixes and reject the three named fixture fragments.
+// @evidence contracts/testing.md#execution-ownership TestServePhaseTraceIsOptInAndPayloadFree is a Go source-unit entry. serveSnapshotRequests performs actual NDJSON decoding and resident lifecycle through the source publisher; prepared projection consumes explicit empty ignore membership. The owning operations stay in this test process, without installing a consumer or building or starting a native product binary. The separate worktree E2E owns real Git acquisition.
 func TestServePhaseTraceIsOptInAndPayloadFree(t *testing.T) {
   root := graphSessionFixture(t)
   request := "{\"id\":17,\"graphSnapshotVersion\":1}\n"
@@ -21,7 +27,7 @@ func TestServePhaseTraceIsOptInAndPayloadFree(t *testing.T) {
   t.Setenv(graphPhaseTraceEnvironment, "")
   var disabled bytes.Buffer
   stderr = &disabled
-  if code := serveSnapshots(strings.NewReader(request), &bytes.Buffer{}, root, "tsconfig.json"); code != 0 {
+  if code := serveSourceSnapshots(strings.NewReader(request), &bytes.Buffer{}, root, "tsconfig.json"); code != 0 {
     t.Fatalf("disabled trace exited %d", code)
   }
   if disabled.Len() != 0 {
@@ -31,7 +37,7 @@ func TestServePhaseTraceIsOptInAndPayloadFree(t *testing.T) {
   t.Setenv(graphPhaseTraceEnvironment, "1")
   var enabled bytes.Buffer
   stderr = &enabled
-  if code := serveSnapshots(strings.NewReader(request), &bytes.Buffer{}, root, "tsconfig.json"); code != 0 {
+  if code := serveSourceSnapshots(strings.NewReader(request), &bytes.Buffer{}, root, "tsconfig.json"); code != 0 {
     t.Fatalf("enabled trace exited %d", code)
   }
   trace := enabled.String()