Werewolf 6p

Six-Player Werewolf

This skill layers werewolf game rules on top of the Room communication kernel. The Room system prompt already documents public @<member> wake semantics and the built-in nexus Room tools; this skill only defines the game contract. The host Agent is always the moderator and never a player.

Game Setup

Resolve participation before assigning any role:

1. Treat the Room host Agent as the permanent moderator. Exclude it from roles, targets, speeches, votes, deaths, and win-condition counts.
2. Ask the user exactly once whether to join as a player or spectate, using AskUserQuestion, unless the opening request already states that choice explicitly.
3. If the user spectates, randomly select six non-host Agent players. The user receives no role and takes no game turn.
4. If the user joins, use 用户玩家 as the stable public name and randomly select five non-host Agent players. Extra non-host Agents are spectators and must not receive role cards or game wakes.
5. Stop before dealing roles if the Room has fewer than six candidate Agent players for spectator mode or fewer than five for user-participation mode. State the exact missing count; never start a partial game.
6. Shuffle the six active players against 2 werewolves + 1 seer + 1 witch + 2 villagers. A participating user enters the same randomized role pool as every Agent player; never hand-pick or restrict the user's role.

The user can only join as a player and can never replace the host. Use the exact participation choices 参加本局 and 仅旁观 so the result is unambiguous.

After the active roster and roles are fixed, announce only the public roster. Keep the participation answer, role mapping, and inactive candidate list out of the public feed.

Wake Plumbing

The game has three execution channels:

• Public feed: a normal public reply containing a non-code @<member> wakes that Agent member. An Agent handoff has exactly one naked @; a handoff to the user has none.
• Agent private channel: use nexus.send_message with destination=current_room and visibility=private for Agent role cards, hidden collection, and host state. A private message can be record-only or can wake Agent recipients.
• User private channel: only the host uses AskUserQuestion for the participation choice, the user's role card, and every hidden user decision. It pauses the host turn until the user answers without publishing the prompt or answer to the Room feed. Player Agents never use it to contact the user.

用户玩家 is not an Agent recipient or wake target. Never place it in send_message.recipients, wake_targets, or a naked public @. When a public chain reaches the user, the preceding Agent stops with no naked @; the user continues through a normal Room message and uses a real @<next Agent> when an Agent should run next.

A user message counts as a speech, vote, last word, or other game action only while the host state is waiting for that exact user turn. Spectator comments and out-of-turn messages never change game state.

For ordered public chains, the current handoff is the only naked @. Future recipients, examples, and format instructions use names without @, or code spans such as `@NextPlayer`. Do not write "please @Sam next" in the host announcement if Sam is not supposed to act now.

When a hidden handback should wake the host and the host's next natural final reply must be public, set reply_route.next_reply_route.mode = "public" on the original directed message. The handback stays private; the host's following final reply enters the public feed and any non-code @ in that reply wakes normally.

Only use nexus.send_message with destination=current_room and visibility=public for an explicit proactive public broadcast from a private/tool-driven turn. This includes the special case where a night transition must become visible before the host blocks on AskUserQuestion for the first hidden actor. Otherwise use next_reply_route={mode:"public"} and a natural host final reply.

Hidden collection must always name the handback route:

{
  "tool": "nexus.send_message",
  "arguments": {
    "destination": "current_room",
    "visibility": "private",
    "recipients": ["<player>"],
    "wake_policy": "immediate",
    "reply_route": {
      "mode": "private",
      "recipients": ["<host>"],
      "wake_policy": "immediate"
    },
    "content": "<question>"
  }
}

The Agent player answers only with the requested plain-text final reply. In a private-message turn, the player must not call any Room tool or append <nexus_room_no_reply/>; runtime already routes that single final reply. Sending the answer again with send_message creates a duplicate handback and can advance the host under the wrong route. If the host's next final reply should be public, include "next_reply_route": {"mode": "public"} on the original message; otherwise omit it and the host can continue with private tool calls plus <nexus_room_no_reply/>.

Public Boundary

A host's public final reply is a game artifact, never an execution-status update. Never expose the private actor, collector, target, decision, or who the host is waiting for. In particular, never output status such as "waiting for Jim's kill target".

• On the opening turn, after participation, role cards, private state, and the first hidden action have been queued, the public night announcement is exactly: 游戏开始，第 1 夜，天黑请闭眼。
• On later night transitions, the exact public announcement is: 进入第 N 夜，天黑请闭眼。
• If the first hidden actor is an Agent, queue its directed message and use the night announcement as the host's natural public final reply.
• If the first hidden actor is the user, publish the night announcement exactly once with send_message(destination=current_room, visibility=public), then call AskUserQuestion in the same host turn. Never reveal why the user is being asked.
• Between private night actions, queue the next action and output exactly <nexus_room_no_reply/>.
• When the final hidden action completes in a public-routed host turn, start the daybreak template immediately. Do not prefix it with private status, duplicate the daybreak heading, or insert ---.

For small-group visibility, send one directed message to all group members and wake only the final collector:

{
  "tool": "nexus.send_message",
  "arguments": {
    "destination": "current_room",
    "visibility": "private",
    "recipients": ["<wolfA>", "<wolfB>"],
    "wake_targets": ["<wolfA>"],
    "wake_policy": "immediate",
    "reply_route": {
      "mode": "private",
      "recipients": ["<host>"],
      "wake_policy": "immediate"
    },
    "content": "你们是狼人。由 <wolfA> 汇总，最终只回复今晚击杀目标。"
  }
}

Both wolves can see the message, but only <wolfA> is activated. This separates private visibility from execution and guarantees one handback route.

Never "open a discussion and wait." The platform will not infer that a small group is done. A named player must hand the result back through reply_route=private(... wake=immediate).

Host private state is also a directed message:

{
  "tool": "nexus.send_message",
  "arguments": {
    "destination": "current_room",
    "visibility": "private",
    "recipients": ["<host>"],
    "wake_policy": "none",
    "reply_route": {"mode": "none"},
    "content": "<round / alive / dead / roles / potion state>"
  }
}

Players And Roles

• 1 permanent host Agent: assigns roles, collects night actions, announces daybreak, organizes speeches, and runs voting. The host is always the moderator and can never receive a role.
• Exactly 6 active players: 2 werewolves, 1 seer, 1 witch, 2 villagers.
• Deliver each Agent role by record-only directed message: recipients=["<player>"], wake_policy="none", reply_route={"mode":"none"}.
• If the user participates, deliver the user's role through AskUserQuestion with one acknowledgement option. Include the same role rules an Agent would receive; if the user is a wolf, name the Agent wolf teammate.
• Each wolf's role card names the other wolf. The joint wolf-action message repeats both wolf names.
• The witch starts with one antidote and one poison; each can be used at most once.
• Host keeps minimal private state by sending record-only directed messages to itself, including whether the user participates and which candidate Agents are inactive.

Win Conditions

• Good side wins when both werewolves are eliminated.
• Werewolves win when all villagers die or all special roles die.
• Check after each daybreak and each voted elimination. The moment a side wins, announce publicly and stop.

Night Flow

Close these steps in order. At the start of each night, build the pending actor list from living active players: wolves, then the seer if alive, then the witch if alive and at least one potion remains. Skip dead or actionless roles. Agent decisions use a directed message with wake_policy="immediate" and reply_route={mode:"private", recipients:["<host>"], wake_policy:"immediate"}; user decisions use AskUserQuestion with only legal living targets as options. The host always expects one hidden result at a time. An invalid or missing target is re-requested from the same actor and never silently substituted.

If the final pending actor is an Agent, give that Agent message next_reply_route={mode:"public"}. If the final pending actor is the user and an Agent acts immediately before it, give the preceding Agent message next_reply_route={mode:"public"}; the resumed host turn asks the user and then publishes daybreak naturally. If the user acts earlier, ask first, queue the next Agent action, and output <nexus_room_no_reply/>.