diff --git a/cmd/server/games.go b/cmd/server/games.go
index c60c6fb..5bfaabf 100644
--- a/cmd/server/games.go
+++ b/cmd/server/games.go
@@ -187,7 +187,7 @@ type (
 	}
 
 	KillWords struct {
-		Codename KillWord
+		Codename Codename
 
 		Assigned time.Time
 		Assignee string
@@ -195,6 +195,11 @@ type (
 		Assignment Assignment
 	}
 
+	Codename struct {
+		KillWord KillWord
+		Consumed bool
+	}
+
 	Assignment struct {
 		Public  []KillWord
 		Private []KillWord
@@ -478,7 +483,7 @@ func (games Games) CreateEventGameReset(ctx context.Context, gid string) error {
 }
 
 func (words KillWords) Empty() bool {
-	return words.Codename == (KillWord{}) && words.Assigned.IsZero() && words.Assignee == "" && words.Assignment.Empty()
+	return words.Codename == (Codename{}) && words.Assigned.IsZero() && words.Assignee == "" && words.Assignment.Empty()
 }
 
 func (words KillWords) Privates() []KillWord {
@@ -607,8 +612,8 @@ func (m AllKillWords) fillKillWords(
 	result := maps.Clone(m)
 	m = result
 	for k, v := range m {
-		if v.Codename.Word == "" {
-			v.Codename = KillWord{Word: m.unusedCodename(poolCodename), Points: 200}
+		if v.Codename.KillWord.Word == "" {
+			v.Codename = Codename{KillWord: KillWord{Word: m.unusedCodename(poolCodename), Points: 200}}
 			m[k] = v
 		}
 		if len(v.Assignment.Public) == 0 {
@@ -633,7 +638,7 @@ func (m AllKillWords) unusedCodename(pool []string) string {
 	inUse := func() []string {
 		result := []string{}
 		for _, killWords := range m {
-			result = append(result, killWords.Codename.Word)
+			result = append(result, killWords.Codename.KillWord.Word)
 		}
 		return result
 	}
diff --git a/cmd/server/games_test.go b/cmd/server/games_test.go
index 99b6b38..e0331a9 100644
--- a/cmd/server/games_test.go
+++ b/cmd/server/games_test.go
@@ -128,7 +128,7 @@ func TestGames(t *testing.T) {
 				if v.Players[p].Points() != 0 {
 					t.Error("nonzero points after zero kills:", v.Players[p].Points())
 				}
-				if v.Players[p].KillWords.Codename.Word == "" {
+				if v.Players[p].KillWords.Codename.KillWord.Word == "" {
 					t.Error(p, "no killwords.Codename")
 				} else if v.Players[p].KillWords.Assigned.IsZero() {
 					t.Error(p, "no killwords.assigned")
@@ -199,10 +199,10 @@ func TestParseEvent(t *testing.T) {
 			},
 			AllKillWords: map[string]KillWords{
 				"x": KillWords{
-					Codename: KillWord{
+					Codename: Codename{KillWord: KillWord{
 						Word:   "a",
 						Points: 200,
-					},
+					}},
 					Assignee: "z",
 					Assigned: now,
 					Assignment: Assignment{
@@ -260,48 +260,48 @@ func TestAllKillWordsFill(t *testing.T) {
 	}{
 		"full": {
 			given: KillWords{
-				Codename:   kw(200, "global"),
+				Codename:   Codename{KillWord: kw(200, "global")},
 				Assignment: ass("pub", "pri"),
 			},
 			expect: KillWords{
-				Codename:   kw(200, "global"),
+				Codename:   Codename{KillWord: kw(200, "global")},
 				Assignment: ass("pub", "pri"),
 			},
 		},
 		"no ass": {
 			given: KillWords{
-				Codename:   kw(200, "global"),
+				Codename:   Codename{KillWord: kw(200, "global")},
 				Assignment: Assignment{},
 			},
 			expect: KillWords{
-				Codename:   kw(200, "global"),
+				Codename:   Codename{KillWord: kw(200, "global")},
 				Assignment: ass("filled-public", "filled-private"),
 			},
 		},
 		"no pub": {
 			given: KillWords{
-				Codename:   kw(200, "global"),
+				Codename:   Codename{KillWord: kw(200, "global")},
 				Assignment: ass("", "pri"),
 			},
 			expect: KillWords{
-				Codename:   kw(200, "global"),
+				Codename:   Codename{KillWord: kw(200, "global")},
 				Assignment: ass("filled-public", "pri"),
 			},
 		},
 		"no pri": {
 			given: KillWords{
-				Codename:   kw(200, "global"),
+				Codename:   Codename{KillWord: kw(200, "global")},
 				Assignment: ass("pub", ""),
 			},
 			expect: KillWords{
-				Codename:   kw(200, "global"),
+				Codename:   Codename{KillWord: kw(200, "global")},
 				Assignment: ass("pub", "filled-private"),
 			},
 		},
 		"empty": {
 			given: KillWords{},
 			expect: KillWords{
-				Codename:   kw(200, "filled-global"),
+				Codename:   Codename{KillWord: kw(200, "filled-global")},
 				Assignment: ass("filled-public", "filled-private"),
 			},
 		},
@@ -310,7 +310,7 @@ func TestAllKillWordsFill(t *testing.T) {
 				Assignment: ass("pub", "pri"),
 			},
 			expect: KillWords{
-				Codename:   kw(200, "filled-global"),
+				Codename:   Codename{KillWord: kw(200, "filled-global")},
 				Assignment: ass("pub", "pri"),
 			},
 		},
@@ -363,7 +363,7 @@ func TestAllKillWordsUnused(t *testing.T) {
 		t.Run("private", func(t *testing.T) {
 			akw := make(AllKillWords)
 			akw["k"] = KillWords{
-				Codename: KillWord{Word: "x"},
+				Codename: Codename{KillWord: KillWord{Word: "x"}},
 				Assignment: Assignment{
 					Private: []KillWord{{}, {Word: "y"}},
 					Public:  []KillWord{{}, {Word: "x"}},
@@ -377,7 +377,7 @@ func TestAllKillWordsUnused(t *testing.T) {
 		t.Run("global", func(t *testing.T) {
 			akw := make(AllKillWords)
 			akw["k"] = KillWords{
-				Codename: KillWord{Word: "y"},
+				Codename: Codename{KillWord: KillWord{Word: "y"}},
 				Assignment: Assignment{
 					Private: []KillWord{{}, {Word: "x"}},
 					Public:  []KillWord{{}, {Word: "x"}},
@@ -391,7 +391,7 @@ func TestAllKillWordsUnused(t *testing.T) {
 		t.Run("public", func(t *testing.T) {
 			akw := make(AllKillWords)
 			akw["k"] = KillWords{
-				Codename: KillWord{Word: "x"},
+				Codename: Codename{KillWord: KillWord{Word: "x"}},
 				Assignment: Assignment{
 					Private: []KillWord{{}, {Word: "x"}},
 					Public:  []KillWord{{}, {Word: "y"}},
diff --git a/cmd/server/usergameserver.go b/cmd/server/usergameserver.go
index f61380d..65bcf35 100644
--- a/cmd/server/usergameserver.go
+++ b/cmd/server/usergameserver.go
@@ -95,7 +95,7 @@ func (ugs *UserGameServer) listen(ctx context.Context, reader func(context.Conte
 			var points int
 			if gameState, err := ugs.games.GameState(ctx, ugs.ID); err != nil {
 				return err
-			} else if codename := gameState.Players[killer].KillWords.Codename; codename.Word == word {
+			} else if codename := gameState.Players[killer].KillWords.Codename.KillWord; codename.Word == word {
 				points = codename.Points
 			} else if matches := slices.DeleteFunc(gameState.Players[victim].KillWords.Publics(), func(kw KillWord) bool { return kw.Word != word }); len(matches) > 0 {
 				points = matches[0].Points
@@ -151,7 +151,7 @@ func (ugs *UserGameServer) State(ctx context.Context) (UserGameState, error) {
 		if isSelf := k == ugs.Session.ID; isSelf {
 			v.KillWords.Assignment = Assignment{}
 		} else {
-			v.KillWords.Codename = KillWord{}
+			v.KillWords.Codename = Codename{}
 			v.KillWords.Assignee = ""
 			for i := range v.Kills {
 				v.Kills[i].Victim = ""
diff --git a/cmd/server/usergameserver_test.go b/cmd/server/usergameserver_test.go
index d710566..f80f81c 100644
--- a/cmd/server/usergameserver_test.go
+++ b/cmd/server/usergameserver_test.go
@@ -83,7 +83,7 @@ func TestUserGameServer(t *testing.T) {
 			}
 
 			if isSelf := pid == ugs.Session.ID; isSelf {
-				if p.KillWords.Codename.Word == "" || p.KillWords.Codename.Points == 0 {
+				if p.KillWords.Codename.KillWord.Word == "" || p.KillWords.Codename.KillWord.Points == 0 {
 					t.Error("self codename missing field")
 				}
 				if p.KillWords.Assignee == "" {
@@ -96,7 +96,7 @@ func TestUserGameServer(t *testing.T) {
 					t.Error("self knows its own private")
 				}
 			} else {
-				if !p.KillWords.Codename.Empty() {
+				if !p.KillWords.Codename.KillWord.Empty() {
 					t.Error("can see not self Codename")
 				}
 				if p.KillWords.Assignee != "" {
@@ -167,7 +167,7 @@ func TestUserGameServer(t *testing.T) {
 				} else if kill.KillWord.Word == "" {
 					t.Errorf("dont know own kill word")
 				}
-				if p.KillWords.Codename.Word == "" || p.KillWords.Codename.Points == 0 {
+				if p.KillWords.Codename.KillWord.Word == "" || p.KillWords.Codename.KillWord.Points == 0 {
 					t.Error("self Codename missing field")
 				}
 				if p.KillWords.Assignee == "" {
@@ -190,7 +190,7 @@ func TestUserGameServer(t *testing.T) {
 				} else if kill.KillWord.Word != "" {
 					t.Errorf("know other's kill word")
 				}
-				if !p.KillWords.Codename.Empty() {
+				if !p.KillWords.Codename.KillWord.Empty() {
 					t.Error("can see not self Codename")
 				}
 				if p.KillWords.Assignee != "" {
@@ -248,7 +248,7 @@ func TestUserGameServer(t *testing.T) {
 				} else if kill.KillWord.Word == "" {
 					t.Errorf("dont know own kill word")
 				}
-				if p.KillWords.Codename.Word == "" || p.KillWords.Codename.Points == 0 {
+				if p.KillWords.Codename.KillWord.Word == "" || p.KillWords.Codename.KillWord.Points == 0 {
 					t.Error("self Codename missing field")
 				}
 				if p.KillWords.Assignee == "" {
@@ -271,7 +271,7 @@ func TestUserGameServer(t *testing.T) {
 				} else if kill.KillWord.Word == "" {
 					t.Errorf("dont know other's kill word")
 				}
-				if p.KillWords.Codename.Empty() {
+				if p.KillWords.Codename.KillWord.Empty() {
 					t.Error("cannot see not self Codename")
 				}
 				if p.KillWords.Assignee == "" {
diff --git a/cmd/server/ws.go b/cmd/server/ws.go
index e79221b..34d476b 100644
--- a/cmd/server/ws.go
+++ b/cmd/server/ws.go
@@ -191,10 +191,8 @@ func (ws WS) inProgressMsgItem(ctx context.Context, ugs *UserGameServer, gameSta
 
 	tags := []inProgressMsgItemTag{}
 
-	if hasBeenKilledWithCodename := slices.ContainsFunc(self.Kills, func(a Kill) bool {
-		return a.Victim == uid && a.KillWord.Word == self.KillWords.Codename.Word
-	}); !hasBeenKilledWithCodename {
-		tags = append(tags, newInProgressMsgItemTag(self.KillWords.Codename))
+	if canKillWithCodename := !self.KillWords.Codename.Consumed; canKillWithCodename {
+		tags = append(tags, newInProgressMsgItemTag(self.KillWords.Codename.KillWord))
 	}
 
 	for _, killWord := range append(