Enhance survival system with economic mechanics and role-specific directives

- Introduced a coin economy where NPCs earn coins for productive actions (gathering, building, slaying beasts).
- Builders can now repair damaged homes, prioritizing base defense over new constructions.
- Newborn NPCs inherit their parents' nation and model connector, ensuring balanced role distribution.
- Updated survival prompts to reflect new survival priorities and rules based on NPC roles (ruler, guard, builder, gatherer).
- Added regression tests to validate the new economic and lifecycle behaviors.

scripts/selfplay_sim.py

@@ -132,6 +132,38 @@ def _parse_briefing(content: str) -> dict[str, object]:
     facts["allies"] = _bullets_section(content, "ALLIES NEAR YOU")
     facts["resources"] = _bullets_section(content, "RESOURCES NEAR YOU")
 
+    # Self-preservation override line printed only when hurt with a threat on you.
+    facts["in_danger"] = "*** DANGER" in content
+
+    # BASE STATUS: which homes need a builder, and where home is (to rest/breed).
+    repair_targets: list[str] = []
+    rebuild_targets: list[str] = []
+    in_base = False
+    for line in content.splitlines():
+        if line.startswith("YOUR BASE"):
+            in_base = True
+            continue
+        if in_base:
+            if line.strip().startswith("- "):
+                mid = re.search(r'"(\S+?)"', line)
+                mpos = re.search(
+                    r'"(\S+?)" at X=(-?\d+(?:\.\d+)?) Z=(-?\d+(?:\.\d+)?)', line
+                )
+                if mid and "DAMAGED" in line:
+                    repair_targets.append(mid.group(1))
+                elif mid and "DESTROYED" in line:
+                    rebuild_targets.append(mid.group(1))
+                if (
+                    mpos
+                    and ("your home" in line or "safe" in line)
+                    and "home_house_pos" not in facts
+                ):
+                    facts["home_house_pos"] = (float(mpos.group(2)), float(mpos.group(3)))
+            elif line.strip() == "" or not line.startswith(" "):
+                in_base = False
+    facts["repair_targets"] = repair_targets
+    facts["rebuild_targets"] = rebuild_targets
+
     m = re.search(r"ACTIONS YOU CAN TAKE: (.+?)\.", content)
     facts["allowed"] = (
         {a.strip() for a in m.group(1).split(",")} if m else {"move", "speak"}
@@ -164,8 +196,40 @@ def _bullets_section(content: str, header: str) -> list[dict[str, object]]:
     return items
 
 
+# Varied speech pools so NPCs sound alive instead of chanting one war cry. The
+# old single hard-coded line was exactly the "zombie raider spam" we are fixing.
+_RULER_ORDERS = [
+    "{ally}, gather food and bank your coins in our treasury.",
+    "Builders, repair our homes before the beast comes back.",
+    "Guards, hold the line and keep the families safe.",
+    "Bring your wages home, {ally} - our nation must grow rich.",
+    "Stay near the houses tonight; we raise the next generation.",
+    "{ally}, watch the eastern approach and report what you see.",
+]
+_CITIZEN_CHATTER = [
+    "Hauling my coins to the treasury, {ally}.",
+    "Careful, {ally} - a beast was prowling nearby.",
+    "I'll gather what I can for us today.",
+    "Our home could use repairs soon.",
+    "Stay safe out there, {ally}.",
+    "Good harvest today - the treasury grows.",
+]
+
+
 def make_fake_completer():
-    """Return a thread-safe completer that decides one action from the briefing."""
+    """Return a thread-safe completer that decides one action from the briefing.
+
+    This stands in for a well-prompted model: it follows the role mandates in the
+    new briefing (rulers govern, builders repair, guards protect, everyone banks
+    coins and flees lethal danger) so the offline ledger shows a living society.
+    """
+
+    def _say(pool: list[str], seed: int, ally_id: str | None, target: str | None):
+        line = pool[seed % len(pool)].format(ally=ally_id or "friend")
+        args: dict[str, object] = {"message": line, "intent": "social"}
+        if target is not None:
+            args["target_id"] = target
+        return _tool_response("speak", args)
 
     def complete(request: dict[str, object]) -> dict[str, object]:
         messages = request.get("messages") or []
@@ -175,16 +239,20 @@ def make_fake_completer():
         f = _parse_briefing(user["content"])
 
         npc_id = str(f["npc_id"])
+        role = str(f["role"])
         tick = int(f["tick"])
         allowed = set(f["allowed"])  # type: ignore[arg-type]
         inv = dict(f["inventory"])  # type: ignore[arg-type]
         threats = list(f["threats"])  # type: ignore[arg-type]
         allies = list(f["allies"])  # type: ignore[arg-type]
         resources = list(f["resources"])  # type: ignore[arg-type]
+        coins = int(inv.get("coins", 0))
+        ally_id = allies[0]["id"] if allies else None
+        own_x, own_z = f["pos"]  # type: ignore[misc]
         seed = (hash(npc_id) ^ (tick * 2654435761)) & 0xFFFFFFFF
 
         # Rarely emit an unusable output so the fallback path is visibly logged.
-        if seed % 41 == 0:
+        if seed % 47 == 0:
             return _unusable_response()
 
         # --- elections: vote when the window is open and we have not voted ---
@@ -192,26 +260,14 @@ def make_fake_completer():
             candidates = list(f["candidates"])  # type: ignore[arg-type]
             return _tool_response("vote", {"candidate_id": candidates[seed % len(candidates)]})
 
-        # --- ruler drives the cannon programme ---
-        if f["is_ruler"]:
-            if "cannon_id" not in f and inv.get("coins", 0) >= 0:
-                # craft only makes sense from the treasury; the ruler tries it.
-                return _tool_response("use", {"use_type": "craft", "params": {"recipe_id": "cannon"}})
-            if "cannon_id" in f and f.get("cannon_operator") is None:
+        # --- SELF-PRESERVATION first: hurt + a threat on you -> flee or shout ---
+        if f["in_danger"]:
+            if seed % 2 == 0:
                 return _tool_response(
-                    "use",
-                    {"use_type": "assign_cannon_operator", "params": {"npc_id": npc_id}},
-                )
-            if "cannon_id" in f and f.get("cannon_operator") == npc_id and "enemy_treasury_pos" in f:
-                ex, ez = f["enemy_treasury_pos"]  # type: ignore[misc]
-                return _tool_response(
-                    "use",
-                    {
-                        "use_type": "fire",
-                        "target_entity_id": f["cannon_id"],
-                        "params": {"x": ex, "z": ez},
-                    },
+                    "speak",
+                    {"message": "Help! A beast is on me!", "intent": "help_request"},
                 )
+            return _tool_response("move", {"away": True})
 
         # --- survival upkeep ---
         if int(f["hunger"]) >= 45 and inv.get("food", 0) > 0:
@@ -219,49 +275,108 @@ def make_fake_completer():
         if int(f["health"]) < 55 and inv.get("herbs", 0) > 0:
             return _tool_response("use", {"use_type": "heal", "resource_type": "herbs"})
 
-        # --- guards engage live threats ---
-        if threats and f["role"] == "guard":
-            return _tool_response("attack", {"target_entity_id": threats[0]["id"]})
-
-        own_x, own_z = f["pos"]  # type: ignore[misc]
-
-        # --- raid the rival treasury for coins ---
-        if "enemy_treasury_pos" in f and int(f["enemy_coins"]) > 0:
-            ex, ez = f["enemy_treasury_pos"]  # type: ignore[misc]
-            dist = abs(ex - own_x) + abs(ez - own_z)
-            if dist <= 6 and seed % 3 == 0:
+        # --- RULER: govern; never personally raid ---
+        if f["is_ruler"]:
+            if "cannon_id" not in f and inv.get("coins", 0) >= 0:
+                return _tool_response("use", {"use_type": "craft", "params": {"recipe_id": "cannon"}})
+            if "cannon_id" in f and f.get("cannon_operator") is None and ally_id:
+                return _tool_response(
+                    "use",
+                    {"use_type": "assign_cannon_operator", "params": {"npc_id": ally_id}},
+                )
+            if coins > 0 and "home_treasury_id" in f:
+                return _tool_response(
+                    "transfer",
+                    {"target_id": f["home_treasury_id"], "resource_type": "coins", "amount": coins},
+                )
+            # Command the nation: address citizens by name with varied orders.
+            return _say(_RULER_ORDERS, seed, ally_id, ally_id)
+
+        # --- GUARD: protect allies and homes; raid only when home is safe ---
+        if role == "guard":
+            if threats:
+                return _tool_response("attack", {"target_entity_id": threats[0]["id"]})
+            if coins >= 3 and "home_treasury_id" in f:
+                return _tool_response(
+                    "transfer",
+                    {"target_id": f["home_treasury_id"], "resource_type": "coins", "amount": coins},
+                )
+            if (
+                "enemy_treasury_pos" in f
+                and int(f["enemy_coins"]) > 0
+                and not f["repair_targets"]
+                and not f["rebuild_targets"]
+            ):
+                ex, ez = f["enemy_treasury_pos"]  # type: ignore[misc]
+                if abs(ex - own_x) + abs(ez - own_z) <= 6 and seed % 3 == 0:
+                    return _tool_response(
+                        "transfer",
+                        {
+                            "target_id": f["enemy_treasury_id"],
+                            "resource_type": "coins",
+                            "amount": 2,
+                            "take": True,
+                        },
+                    )
+                if seed % 11 == 0:
+                    return _tool_response("move", {"x": ex, "z": ez})
+            # Otherwise stay home and stand guard / earn.
+            if resources:
+                return _tool_response("use", {"use_type": "gather", "resource_id": resources[0]["id"]})
+            return _tool_response("move", {"x": own_x, "z": own_z})
+
+        # --- BUILDER: repair/raise homes before anything else ---
+        if role == "builder":
+            if f["repair_targets"]:
+                return _tool_response("use", {"use_type": "repair"})
+            if f["rebuild_targets"]:
+                return _tool_response("use", {"use_type": "build"})
+            if coins >= 3 and "home_treasury_id" in f:
                 return _tool_response(
                     "transfer",
-                    {
-                        "target_id": f["enemy_treasury_id"],
-                        "resource_type": "coins",
-                        "amount": 2,
-                        "take": True,
-                    },
+                    {"target_id": f["home_treasury_id"], "resource_type": "coins", "amount": coins},
                 )
-            if seed % 13 == 0:
-                # March toward the rival treasury to attempt a raid later.
-                return _tool_response("move", {"x": ex, "z": ez})
+            wood_nodes = [r for r in resources if "wood" in str(r.get("id", ""))]
+            if wood_nodes:
+                return _tool_response("use", {"use_type": "gather", "resource_id": wood_nodes[0]["id"]})
+            if inv.get("wood", 0) >= 5:
+                return _tool_response("use", {"use_type": "build"})
+            if resources:
+                return _tool_response("use", {"use_type": "gather", "resource_id": resources[0]["id"]})
+
+        # --- bank wages: everyone carries coins home to enrich the nation ---
+        if coins >= 2 and "home_treasury_id" in f:
+            return _tool_response(
+                "transfer",
+                {"target_id": f["home_treasury_id"], "resource_type": "coins", "amount": coins},
+            )
 
-        # --- periodically deposit surplus into the home treasury ---
+        # --- deposit other surplus occasionally ---
         if "home_treasury_id" in f and seed % 6 == 0:
             for res in ("wood", "food", "herbs"):
-                if inv.get(res, 0) > 0:
+                if inv.get(res, 0) > 1:
                     return _tool_response(
                         "transfer",
                         {"target_id": f["home_treasury_id"], "resource_type": res, "amount": 1},
                     )
 
-        # --- occasionally chat with a nearby ally ---
-        if allies and seed % 9 == 0:
-            partner = allies[0]
-            return _tool_response(
-                "speak",
-                {"message": "Let us raid the enemy treasury together!",
-                 "target_id": partner["id"]},
-            )
-
-        # --- default: gather the nearest reachable resource, else wander ---
+        # --- when safe, fed and healthy, rest at home to raise a family ---
+        if (
+            int(f["health"]) >= 85
+            and int(f["hunger"]) <= 35
+            and not threats
+            and coins == 0
+            and "home_house_pos" in f
+            and seed % 2 == 0
+        ):
+            hx, hz = f["home_house_pos"]  # type: ignore[misc]
+            return _tool_response("move", {"x": hx, "z": hz})
+
+        # --- gather to earn coins, with the occasional friendly word ---
+        if resources and seed % 7 != 0:
+            return _tool_response("use", {"use_type": "gather", "resource_id": resources[0]["id"]})
+        if allies and seed % 5 == 0:
+            return _say(_CITIZEN_CHATTER, seed, ally_id, ally_id)
         if resources:
             return _tool_response("use", {"use_type": "gather", "resource_id": resources[0]["id"]})
 

src/world_simulator/simulation/connectors/openai_compatible.py

@@ -784,34 +784,87 @@ def _build_survival_messages(
 def _survival_system_prompt(
     npc: Npc, country_name: str, allowed_actions: Sequence[str]
 ) -> str:
+    role = normalize_role(npc.role)
+    is_ruler = npc.special_status == "ruler"
     lines = [
-        f"You are {npc.name}, a {npc.role} of {country_name}. You are a living "
-        "person who wants to SURVIVE and help your nation WIN THE WAR against the "
-        "rival nation.",
+        f"You are {npc.name}, a {'ruler' if is_ruler else role} of {country_name}. "
+        "You are a living person with a job and a family to think about, not a "
+        "mindless raider.",
         "Read the BRIEFING below, decide your single best next action, then call "
-        "exactly one tool. NEVER write prose, JSON, or explanations.",
-        "CRITICAL RULES:",
-        "- To go ANYWHERE you MUST call move with BOTH x and z set to the "
-        "destination coordinates from the briefing. A move without x and z just "
-        "wanders in place and WASTES the turn.",
-        "- You travel only about 1 step per turn, so keep moving toward the SAME "
-        "coordinates for many turns to cross the map. Each turn the briefing shows "
-        "your distance to the enemy: if it is NOT shrinking, you are going the "
-        "wrong way.",
-        "- EAT when your hunger is high and HEAL when your health is low, or you "
-        "will DIE.",
-        "- To loot the enemy: MOVE to the enemy treasury coordinates over several "
-        "turns, and once you are next to it call transfer with take=true on that "
-        "treasury id.",
-        "- COORDINATE with allies: when you speak, give a concrete plan with exact "
-        "coordinates, e.g. \"March to X=80 Z=6 and raid the enemy treasury "
-        "together\".",
-        "- Use ONLY the ids and coordinates printed in the briefing. NEVER invent "
-        "an id.",
+        "EXACTLY ONE tool. NEVER write prose, JSON, or explanations.",
+        "",
+        "WHAT YOUR NATION NEEDS (in this order):",
+        "1. SURVIVE - keep yourself and your neighbours alive: eat when hungry, "
+        "heal when hurt, run from things that can kill you.",
+        "2. GROW - children are only born to healthy adults resting safely in a "
+        "house, so protect your homes and raise the next generation.",
+        "3. PROSPER - earn coins from honest work (gathering, building, slaying "
+        "beasts) and deposit them in YOUR treasury to make your nation rich. "
+        "Pointless raids that get you killed help no one.",
+        "",
+        "SURVIVAL INSTINCT - THIS OVERRIDES EVERYTHING:",
+        "- If your health is low and a threat is near, do NOT fight to the death. "
+        "RIGHT NOW either FLEE (move with away=true) OR CALL FOR HELP "
+        "(speak with intent=help_request). Staying alive is always the priority.",
+        "- EAT when hunger is high (use use_type=eat) and HEAL when health is low "
+        "(use use_type=heal), or you will die.",
+        "",
+        "HOMES & FAMILY:",
+        "- You can only raise a child while safe inside a completed house. If your "
+        "home is DAMAGED, get a builder to repair it; if you have no home, move "
+        "into a completed house - even an empty one a dead neighbour left behind.",
+        "",
+        "MOVEMENT:",
+        "- To go ANYWHERE you MUST call move with BOTH x and z set to coordinates "
+        "from the briefing. A move without x and z just wanders and WASTES the turn.",
+        "- You travel about 1 step per turn, so keep aiming at the SAME coordinates "
+        "for many turns to cross the map.",
+        "",
+        "TALKING - SOUND ALIVE:",
+        "- React to what is actually happening this turn and to what others just "
+        "said. Speak in your own voice and address people by name. NEVER repeat a "
+        "sentence you or anyone else already said - no copy-pasted war cries.",
+        "",
+        "Use ONLY the ids and coordinates printed in the briefing. NEVER invent one.",
+        "",
+        _role_mandate(role, is_ruler),
     ]
     return "\n".join(lines)
 
 
+def _role_mandate(role: str, is_ruler: bool) -> str:
+    if is_ruler:
+        return (
+            "YOUR ROLE - RULER: You GOVERN your nation; you do NOT run off on raids. "
+            "Read the events, set direction, and command citizens BY NAME with speak "
+            "(give concrete, varied orders: who gathers, who guards, who builds or "
+            "repairs, who banks coins). Watch your treasury, keep your people fed, "
+            "safe and breeding, and defend the homes. Only sanction an attack on a "
+            "clear, present threat."
+        )
+    if role == "guard":
+        return (
+            "YOUR ROLE - GUARD: Your instinct is PROTECTION. When a beast or enemy "
+            "threatens an ally or a home, ATTACK it (do not merely move past it); "
+            "hunt beasts before they reach the houses. You earn coins for every "
+            "beast you slay - carry them to your treasury and deposit them."
+        )
+    if role == "builder":
+        return (
+            "YOUR ROLE - BUILDER: Your instinct is SHELTER. If ANY home is damaged, "
+            "REPAIR IT NOW (use use_type=repair) - a standing home outweighs any "
+            "raid. Gather wood and raise new houses so families can grow. You earn "
+            "coins for building and repairing - deposit them in your treasury. "
+            "Avoid fights: flee threats and call for help."
+        )
+    return (
+        "YOUR ROLE - GATHERER: Your instinct is SUPPLY. Keep food and herbs "
+        "flowing and gather resources (you earn coins for each one). Share food "
+        "with the hungry and carry your coins home to the treasury. Avoid fights: "
+        "flee threats and call for help."
+    )
+
+
 def _survival_briefing_lines(
     world: WorldState,
     next_tick: int,
@@ -822,10 +875,13 @@ def _survival_briefing_lines(
 ) -> list[str]:
     pos = npc.position
     lines: list[str] = []
+    role = normalize_role(npc.role)
+    is_ruler = npc.special_status == "ruler"
+    threats = _survival_nearby_threats(world, npc)
 
     # --- identity + needs -------------------------------------------------- #
     lines.append(
-        f"YOU are {npc.name} ({npc.id}), a {npc.role}"
+        f"YOU are {npc.name} ({npc.id}), a {'ruler' if is_ruler else npc.role}"
         + (f" of {country.name}" if country else "")
         + f". Turn {next_tick}."
     )
@@ -839,6 +895,15 @@ def _survival_briefing_lines(
     lines.append(f"YOUR POSITION: {_loc(pos.x, pos.z)}.")
     lines.append(f"RIGHT NOW your instinct says: {_goal_word(goal)}.")
 
+    # --- self-preservation override: hurt + a threat on you = flee/shout ---- #
+    if threats and npc.health < 50:
+        nearest = threats[0]
+        lines.append(
+            f"*** DANGER: you are hurt and {nearest['id']} is near. Do NOT fight to "
+            "the death. FLEE NOW (move away=true) OR CALL FOR HELP "
+            "(speak intent=help_request). ***"
+        )
+
     # --- urgent survival directives (spelled out like raid/gather) ---------- #
     if npc.hunger >= 60 and npc.inventory_food > 0:
         lines.append(
@@ -876,15 +941,36 @@ def _survival_briefing_lines(
             coins = rival.treasury.resources.get("coins", 0)
             wood = rival.treasury.resources.get("wood", 0)
             lines.append(
-                f"  LOOT TARGET - enemy treasury \"{rival.treasury.id}\" at "
+                f"  The enemy treasury \"{rival.treasury.id}\" at "
                 f"{_loc(tpos.x, tpos.z)} - {_bearing_to(pos, tpos.x, tpos.z)}. "
                 f"Holds {coins} coins, {wood} wood."
             )
-            lines.append(
-                f"  TO RAID IT: move x={_num(tpos.x)} z={_num(tpos.z)} every turn "
-                f"until you arrive, then transfer take=true "
-                f"target_id={rival.treasury.id} resource_type=coins."
+            base_in_danger = bool(threats) or any(
+                h.state == "destroyed" or (h.state == "completed" and h.hp < h.max_hp)
+                for h in world.houses
             )
+            if is_ruler:
+                lines.append(
+                    "  (As ruler you direct the nation from home - you do NOT raid "
+                    "in person. Send a guard only if the base is safe.)"
+                )
+            elif base_in_danger or npc.health < 50:
+                lines.append(
+                    "  This is NOT the time to raid - your base or your life is at "
+                    "risk. Defend, repair, and survive first."
+                )
+            elif role == "guard":
+                lines.append(
+                    f"  RAID OPTION (guard): if home is safe, march move "
+                    f"x={_num(tpos.x)} z={_num(tpos.z)} toward it over many turns, "
+                    f"then transfer take=true target_id={rival.treasury.id} "
+                    "resource_type=coins."
+                )
+            else:
+                lines.append(
+                    "  Leave raids to the guards - your own work and survival come "
+                    "first."
+                )
 
     # --- your nation ------------------------------------------------------- #
     if country is not None:
@@ -905,6 +991,12 @@ def _survival_briefing_lines(
                 f"{res.get('food', 0)} food. (Deposit with transfer "
                 f"target_id={country.treasury.id}.)"
             )
+            if npc.inventory_coins > 0:
+                lines.append(
+                    f"  You are carrying {npc.inventory_coins} coins of wages - bring "
+                    f"them home and transfer target_id={country.treasury.id} "
+                    "resource_type=coins to enrich your nation."
+                )
         if country.cannon is not None:
             cpos = country.cannon.position
             op = country.cannon.operator_id or "none"
@@ -923,7 +1015,6 @@ def _survival_briefing_lines(
             )
 
     # --- threats ----------------------------------------------------------- #
-    threats = _survival_nearby_threats(world, npc)
     lines.append("")
     if threats:
         lines.append("THREATS NEAR YOU:")
@@ -984,38 +1075,73 @@ def _survival_briefing_lines(
     else:
         lines.append("RESOURCES NEAR YOU: none in sight (move to find some).")
 
-    # --- shelter ----------------------------------------------------------- #
-    houses = _survival_houses_with_capacity(world)
-    if houses:
-        h = houses[0]
-        hp = h.get("position") or {}
-        if "x" in hp:
-            lines.append(
-                f"SHELTER: house \"{h['id']}\" at {_loc(hp['x'], hp['z'])} "
-                f"({_bearing_to(pos, hp['x'], hp['z'])}), {h['free_capacity']} free spots."
-            )
+    # --- base & shelter ---------------------------------------------------- #
+    lines.append("")
+    lines.append("YOUR BASE:")
+    base_houses = sorted(
+        world.houses, key=lambda house: vec_distance(pos, house.position)
+    )[:4]
+    if base_houses:
+        for house in base_houses:
+            hpos = house.position
+            where = f"{_loc(hpos.x, hpos.z)} ({_bearing_to(pos, hpos.x, hpos.z)})"
+            if house.state == "destroyed":
+                lines.append(
+                    f"  - house \"{house.id}\" at {where} is DESTROYED - a builder "
+                    "must rebuild it (use use_type=build)."
+                )
+            elif house.state == "completed" and house.hp < house.max_hp:
+                lines.append(
+                    f"  - house \"{house.id}\" at {where} is DAMAGED "
+                    f"({round(house.hp)}/{round(house.max_hp)} hp) - a builder must "
+                    "REPAIR it (use use_type=repair)."
+                )
+            else:
+                free = max(
+                    0,
+                    house.capacity
+                    - len([o for o in house.occupant_ids if o]),
+                )
+                state = "your home" if house.id == npc.home_house_id else "safe"
+                lines.append(
+                    f"  - house \"{house.id}\" at {where} is {state} "
+                    f"({round(house.hp)}/{round(house.max_hp)} hp, {free} free spots)."
+                )
+    else:
+        lines.append("  - no houses standing - a builder must raise one.")
+    if not is_ruler and npc.health >= 80 and npc.hunger <= 40 and not threats:
+        lines.append(
+            "  When the base is calm, rest inside a completed house to raise the "
+            "next child for your nation."
+        )
 
     # --- action menu ------------------------------------------------------- #
     lines.append("")
     lines.append("ACTIONS YOU CAN TAKE: " + ", ".join(allowed_actions) + ".")
-    lines.append(_role_tip(npc.role))
+    lines.append(_role_tip(npc.role, is_ruler=is_ruler))
     return lines
 
 
-def _role_tip(role: str) -> str:
+def _role_tip(role: str, *, is_ruler: bool = False) -> str:
+    if is_ruler:
+        return (
+            "REMINDER: you are the ruler. Govern from safety - command citizens by "
+            "name with speak, watch the treasury, and keep your people alive and "
+            "growing. Do not wander off to raid."
+        )
     if role == "guard":
         return (
-            "As a guard you should hunt beasts and hostile enemies, defend allies, "
-            "and lead raids on the enemy."
+            "REMINDER: as a guard, protect allies and homes first - attack beasts "
+            "and enemies that threaten them, and bank the coins you earn."
         )
     if role == "builder":
         return (
-            "As a builder you gather wood and raise shelter, but you still fight "
-            "and raid when your nation needs it."
+            "REMINDER: as a builder, repair damaged homes and raise new ones so "
+            "families can grow; gather wood, bank your coins, and avoid fights."
         )
     return (
-        "As a gatherer you keep food and supplies flowing, but you still join "
-        "raids and defend your nation when needed."
+        "REMINDER: as a gatherer, keep food and herbs flowing, bank your coins, "
+        "share with the hungry, and avoid fights - flee danger and call for help."
     )
 
 
@@ -1038,16 +1164,17 @@ def _hunger_word(hunger: float) -> str:
 def _goal_word(goal: str) -> str:
     return {
         "dead": "nothing - you are dead",
-        "help_ally": "rush to help an ally under attack",
-        "engage_threat": "fight the nearby threat",
-        "survive_threat_flee": "flee from the nearby beast",
+        "help_ally": "rush to defend an ally under attack",
+        "engage_threat": "fight off the threat to protect the base",
+        "survive_threat_fight": "fight back, but flee or shout for help if you are losing",
+        "survive_threat_flee": "FLEE the beast (move away=true) or CALL FOR HELP now",
         "heal_self": "heal yourself with herbs",
         "eat_food": "eat to stop starving",
         "find_food": "find and gather food",
         "find_herbs": "find healing herbs",
-        "obey_directive": "follow your orders",
-        "settle": "you are safe - push the war effort",
-        "work": "do useful work or advance the war",
+        "obey_directive": "follow your ruler's orders",
+        "settle": "you are safe - rest at home, raise a family, bank your coins",
+        "work": "do your job - earn coins and strengthen your nation",
     }.get(goal, goal.replace("_", " "))
 
 
@@ -1229,25 +1356,6 @@ def _survival_reachable_resources(world: WorldState, npc: Npc) -> list[dict[str,
     return sorted(resources, key=lambda item: (item["distance"], item["id"]))[:6]
 
 
-def _survival_houses_with_capacity(world: WorldState) -> list[dict[str, Any]]:
-    houses: list[dict[str, Any]] = []
-    living_ids = {npc.id for npc in world.living_npcs()}
-    for house in world.houses:
-        occupants = [npc_id for npc_id in house.occupant_ids if npc_id in living_ids]
-        free = max(0, house.capacity - len(occupants))
-        if house.state != "completed" or house.hp <= 0 or free <= 0:
-            continue
-        houses.append(
-            {
-                "id": house.id,
-                "hp": round(house.hp),
-                "free_capacity": free,
-                "position": {"x": house.position.x, "z": house.position.z},
-            }
-        )
-    return houses[:5]
-
-
 def _npc_context(
     world: WorldState,
     npc: Npc,

src/world_simulator/simulation/survival.py

@@ -61,6 +61,10 @@ HEAL_GOAL_HEALTH = 40  # health < this (with herbs) -> heal_self
 FIND_HERBS_HEALTH = 50  # health < this (without herbs) -> find_herbs
 EAT_GOAL_HUNGER = 60.0
 REPRODUCTION_SNACK_HUNGER = 45.0
+# A would-be parent only needs to be reasonably fed (not literally stuffed) to
+# have a child. Set well below REPRODUCTION_SNACK_HUNGER so a single meal closes
+# the gap, otherwise families almost never form within a demo run.
+REPRODUCTION_MAX_HUNGER = 25.0
 
 # Awareness radii (world units).
 BEAST_ALERT_RADIUS = 6 * TILE
@@ -80,6 +84,10 @@ SPEECH_RADIUS = 6 * TILE  # how far ordinary speech/shouts are heard by others
 HOUSE_RADIUS = 2.5 * TILE
 HOUSE_BUILD_RADIUS = 2 * TILE
 HOUSE_MIN_DISTANCE = 4 * TILE
+# Repairing a standing-but-damaged home: cheap, fast, and the builder's top job
+# when beasts are chewing on the base. Distinct from rebuilding a destroyed ruin.
+HOUSE_REPAIR_PER_ACTION = 12.0
+HOUSE_REPAIR_WOOD_COST = 1
 
 # Fear dynamics.
 FEAR_ON_ATTACK = 60.0
@@ -96,6 +104,15 @@ FLEE_STEP = 2 * TILE
 NPC_MELEE_REACH = ATTACK_RADIUS  # one tile, shared with beasts (see mechanics.ATTACK_RADIUS)
 BASE_NPC_DAMAGE = 10
 WEAPON_DAMAGE_BONUS = 0
+
+# Coin economy: productive work pays a wage the citizen banks in the treasury, so
+# the nation grows rich through labour (gathering, building, hunting) rather than
+# only through raids. Wages land in inventory_coins; a transfer to the treasury
+# turns them into national wealth (treasury_deposit events).
+COINS_PER_GATHER = 1
+COINS_PER_BUILD_TICK = 1
+COINS_ON_BUILD_COMPLETE = 4
+COINS_PER_BEAST_KILL = 6
 GUARD_DAMAGE_MULTIPLIER = 1.5
 WEAK_DAMAGE_MULTIPLIER = 0.3
 BEAST_RETREAT_HEALTH = 20.0
@@ -1378,6 +1395,9 @@ def _maybe_reproduce(world: WorldState, parent: Npc, next_tick: int) -> None:
 
     role = _role_for_child(world, parent)
     child_index = _next_npc_index(world)
+    # A child belongs to its parents' nation and is driven by the same model
+    # (connector). Without inheriting these the newborn is stateless: no country,
+    # no treasury to fund, and wrongly routed to the default model.
     child = Npc(
         id=f"npc-{child_index:03d}",
         name=_child_name(child_index),
@@ -1391,8 +1411,17 @@ def _maybe_reproduce(world: WorldState, parent: Npc, next_tick: int) -> None:
         max_age=random.Random(f"{world.seed}:{next_tick}:{child_index}:max_age").randint(320, 480),
         inventory_weapon=1 if role == "guard" else 0,
         home_house_id=house.id,
+        country_id=parent.country_id,
+        connector_id=parent.connector_id,
+        unrestricted_actions=parent.unrestricted_actions,
+        model_profile_id=parent.model_profile_id,
+        personality=parent.personality,
         memory=[MemoryEntry(tick=next_tick, text=f"Born in {house.id} as a {role}.")],
     )
+    if parent.country_id is not None:
+        country = country_for_npc(world, parent)
+        if country is not None and child.id not in country.citizen_ids:
+            country.citizen_ids.append(child.id)
     for npc in world.living_npcs():
         if npc.id == child.id:
             continue
@@ -1445,7 +1474,7 @@ def _maybe_reproduce(world: WorldState, parent: Npc, next_tick: int) -> None:
 def _reproduction_conditions_met(world: WorldState, npc: Npc) -> bool:
     return (
         npc.health >= 95
-        and npc.hunger <= 5
+        and npc.hunger <= REPRODUCTION_MAX_HUNGER
         and round(npc.safety) >= 100
         and npc.age > 90
         and npc.reproduction_cooldown == 0
@@ -1463,6 +1492,10 @@ def _house_has_threat(world: WorldState, house: House) -> bool:
 def _role_for_child(world: WorldState, parent: Npc) -> str:
     counts = {role: 0 for role in ("gatherer", "guard", "builder")}
     for npc in world.living_npcs():
+        # Balance professions within the child's own nation so each country keeps
+        # gatherers, guards and builders rather than drifting to one role.
+        if parent.country_id is not None and npc.country_id != parent.country_id:
+            continue
         counts[normalize_role(npc.role)] += 1
     total = max(1, sum(counts.values()))
     targets = {"gatherer": 3 / 6, "guard": 2 / 6, "builder": 1 / 6}
@@ -1597,7 +1630,7 @@ def select_goal(npc: Npc, world: WorldState) -> str:
     if (
         _is_reproduction_candidate(npc)
         and npc.inventory_food > 0
-        and 5 < npc.hunger <= REPRODUCTION_SNACK_HUNGER
+        and REPRODUCTION_MAX_HUNGER < npc.hunger <= REPRODUCTION_SNACK_HUNGER
     ):
         return "eat_food"
     if npc.hunger >= EAT_GOAL_HUNGER and npc.inventory_food > 0:
@@ -1716,6 +1749,11 @@ def validate_survival_action(
             house = _house_by_id(world, npc.build_target_house_id)
             if house is not None and house.state == "under_construction":
                 return "build"
+        if (
+            _nearest_damaged_house(world, npc.position) is not None
+            and npc.inventory_wood >= HOUSE_REPAIR_WOOD_COST
+        ):
+            return "build"
         return "build" if npc.inventory_wood >= 5 else "move_to_resource"
     if action == "craft":
         return "craft" if _can_craft_cannon(world, npc) else "idle"
@@ -1922,6 +1960,7 @@ def apply_action_effects(
         if node is not None and node.amount > 0:
             node.amount -= 1
             _add_to_inventory(npc, node.resource_type)
+            _earn_coins(npc, world, COINS_PER_GATHER, f"gathering {node.resource_type}")
             add_episode(
                 npc,
                 world.tick,
@@ -2071,6 +2110,7 @@ def apply_action_effects(
                 npc.beasts_killed += 1
                 world.beasts_killed += 1
                 world.overseer_score += 2
+                _earn_coins(npc, world, COINS_PER_BEAST_KILL, f"slaying {beast.id}")
                 _record_world_event(
                     world,
                     "beast_killed",
@@ -2432,6 +2472,35 @@ def _overhear_speech(
 def _apply_build(npc: Npc, world: WorldState) -> str:
     half_width = world.terrain.width / 2
     half_depth = world.terrain.depth / 2
+
+    # Priority 0: patch up a standing-but-damaged home before it collapses.
+    # Defending the base outranks finishing a new build or hauling more wood.
+    damaged = _nearest_damaged_house(world, npc.position)
+    if damaged is not None and npc.inventory_wood >= HOUSE_REPAIR_WOOD_COST:
+        if vec_distance(npc.position, damaged.position) > HOUSE_BUILD_RADIUS:
+            npc.position = move_toward(
+                npc.position,
+                damaged.position,
+                NPC_MOVE_STEP,
+                half_width=half_width,
+                half_depth=half_depth,
+            )
+            return f"rushing to repair {damaged.id}"
+        npc.inventory_wood -= HOUSE_REPAIR_WOOD_COST
+        before = damaged.hp
+        damaged.hp = min(damaged.max_hp, damaged.hp + HOUSE_REPAIR_PER_ACTION)
+        _earn_coins(npc, world, COINS_PER_BUILD_TICK, f"repairing {damaged.id}")
+        _log_event(
+            world,
+            "house_repaired",
+            f"{npc.name} repaired {damaged.id} (+{round(damaged.hp - before)} hp)",
+            severity="good",
+            actor_id=npc.id,
+            target_id=damaged.id,
+        )
+        remember(npc, world.tick, f"You repaired {damaged.id}.")
+        return f"repairing {damaged.id}"
+
     active_house = _house_by_id(world, npc.build_target_house_id or "")
     if active_house is not None and active_house.state == "under_construction":
         distance = vec_distance(npc.position, active_house.position)
@@ -2445,6 +2514,7 @@ def _apply_build(npc: Npc, world: WorldState) -> str:
             )
             return f"returning to build {active_house.id}"
         active_house.build_progress += 1
+        _earn_coins(npc, world, COINS_PER_BUILD_TICK, f"building {active_house.id}")
         if npc.id not in active_house.owner_ids:
             active_house.owner_ids.append(npc.id)
         if active_house.build_progress >= 10:
@@ -2454,6 +2524,7 @@ def _apply_build(npc: Npc, world: WorldState) -> str:
             npc.houses_built += 1
             world.houses_built += 1
             world.overseer_score += 2
+            _earn_coins(npc, world, COINS_ON_BUILD_COMPLETE, f"completing {active_house.id}")
             _record_world_event(
                 world,
                 "build_completed",
@@ -2744,6 +2815,18 @@ def _nearest_destroyed_house(world: WorldState, position: Vec3) -> House | None:
     return min(ruins, key=lambda house: (vec_distance(position, house.position), house.id))
 
 
+def _nearest_damaged_house(world: WorldState, position: Vec3) -> House | None:
+    """Nearest standing home that has taken damage but is not yet destroyed."""
+    damaged = [
+        house
+        for house in world.houses
+        if house.state == "completed" and 0 < house.hp < house.max_hp
+    ]
+    if not damaged:
+        return None
+    return min(damaged, key=lambda house: (vec_distance(position, house.position), house.id))
+
+
 def _can_start_house(world: WorldState, position: Vec3) -> bool:
     return all(vec_distance(position, house.position) >= HOUSE_MIN_DISTANCE for house in world.houses)
 
@@ -2967,6 +3050,20 @@ def _message_for_intent(intent: str) -> str:
     return "How are you holding up?"
 
 
+def _earn_coins(npc: Npc, world: WorldState, amount: int, reason: str) -> None:
+    """Pay an NPC a coin wage for productive work and log it as income."""
+    if amount <= 0:
+        return
+    npc.inventory_coins += amount
+    _log_event(
+        world,
+        "coins_earned",
+        f"{npc.name} earned {amount} coins by {reason}",
+        severity="good",
+        actor_id=npc.id,
+    )
+
+
 def _add_to_inventory(npc: Npc, resource_type: str) -> None:
     _add_to_inventory_amount(npc, resource_type, 1)
 
@@ -3460,7 +3557,7 @@ def _plan_directive(
         if (
             house is not None
             and _is_reproduction_candidate(npc)
-            and 5 < npc.hunger <= REPRODUCTION_SNACK_HUNGER
+            and REPRODUCTION_MAX_HUNGER < npc.hunger <= REPRODUCTION_SNACK_HUNGER
             and npc.inventory_food > 0
         ):
             return directive("consume")
@@ -3480,6 +3577,9 @@ def _plan_directive(
         if role == "guard":
             return directive("patrol")
         if role == "builder":
+            damaged = _nearest_damaged_house(world, npc.position)
+            if damaged is not None and npc.inventory_wood >= HOUSE_REPAIR_WOOD_COST:
+                return directive("build")  # _apply_build repairs the damaged home first
             if npc.build_target_house_id or npc.inventory_wood >= 5:
                 return directive("build")
             node = _spread_resource(world, npc, index, resource_type="wood")

tests/test_economy_and_lifecycle.py

@@ -0,0 +1,168 @@
+"""Regression tests for the goal.md "living society" fixes.
+
+These pin the behaviours that turned spamming zombie-raiders back into a working
+civilisation:
+
+* productive work pays a coin wage (gather / build / slay a beast) so citizens
+  can bank wealth in the treasury instead of only stealing it;
+* builders repair a standing-but-damaged home (not just rebuild ruins);
+* a newborn inherits its parents' nation AND model connector and a balanced role.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from world_simulator.config import load_game_config
+from world_simulator.domain import (
+    Beast,
+    House,
+    Npc,
+    ResourceNode,
+    Terrain,
+    Vec3,
+    WorldState,
+)
+from world_simulator.simulation.connectors.base import NpcDirective
+from world_simulator.simulation.spawning import create_world
+from world_simulator.simulation.survival import (
+    COINS_ON_BUILD_COMPLETE,
+    COINS_PER_BEAST_KILL,
+    COINS_PER_GATHER,
+    HOUSE_REPAIR_PER_ACTION,
+    _maybe_reproduce,
+    apply_action_effects,
+    validate_survival_action,
+)
+
+
+def _npc(npc_id: str = "npc-001", name: str = "Ada", *, role: str = "gatherer",
+         x: float = 0.0, z: float = 0.0, **state: object) -> Npc:
+    return Npc(id=npc_id, name=name, role=role, position=Vec3(x=x, y=0.0, z=z), **state)  # type: ignore[arg-type]
+
+
+def _world(npcs: list[Npc], **kw: object) -> WorldState:
+    return WorldState(
+        tick=int(kw.pop("tick", 0)),  # type: ignore[arg-type]
+        seed=42,
+        terrain=Terrain(kind="plain_green", width=80, depth=80),
+        npcs=npcs,
+        resource_nodes=kw.pop("resource_nodes", []),  # type: ignore[arg-type]
+        beasts=kw.pop("beasts", []),  # type: ignore[arg-type]
+        houses=kw.pop("houses", []),  # type: ignore[arg-type]
+    )
+
+
+# --------------------------------------------------------------------------- #
+# Coin economy: honest work pays a wage
+# --------------------------------------------------------------------------- #
+def test_gather_pays_a_coin_wage() -> None:
+    npc = _npc(role="gatherer", x=0.0, z=0.0)
+    node = ResourceNode("res_food_1", "food", Vec3(1.0, 0.0, 0.0), amount=3)
+    world = _world([npc], resource_nodes=[node])
+
+    apply_action_effects(npc, "use", world)
+
+    assert npc.inventory_food == 1
+    assert npc.inventory_coins == COINS_PER_GATHER
+    assert any(e.type == "coins_earned" for e in world.event_log)
+
+
+def test_beast_kill_pays_a_coin_wage() -> None:
+    guard = _npc(role="guard", x=0.0, z=0.0, inventory_weapon=1)
+    beast = Beast("beast_1", Vec3(1.0, 0.0, 0.0), health=5.0)
+    world = _world([guard], beasts=[beast])
+
+    directive = NpcDirective(npc_id=guard.id, action="attack", target_entity_id="beast_1")
+    apply_action_effects(guard, "attack", world, directive=directive)
+
+    assert beast.state == "dead"
+    assert guard.inventory_coins == COINS_PER_BEAST_KILL
+
+
+# --------------------------------------------------------------------------- #
+# Builders repair a damaged home, not only rebuild ruins
+# --------------------------------------------------------------------------- #
+def test_builder_repairs_damaged_home_and_earns_coins() -> None:
+    builder = _npc(role="builder", x=0.0, z=0.0, inventory_wood=3)
+    house = House("house_1", Vec3(0.0, 0.0, 0.0), hp=20.0, max_hp=60.0, state="completed")
+    world = _world([builder], houses=[house])
+
+    directive = NpcDirective(npc_id=builder.id, action="use", use_type="repair")
+    verb = validate_survival_action(builder, directive.action, world, directive)
+    assert verb == "build"  # repair routes through the build effect
+    summary = apply_action_effects(builder, verb, world, directive=directive)
+
+    assert "repair" in summary.lower()
+    assert house.hp == 20.0 + HOUSE_REPAIR_PER_ACTION
+    assert builder.inventory_wood == 2  # repair costs one wood
+    assert builder.inventory_coins >= 1  # repair pays a wage
+    assert any(e.type == "house_repaired" for e in world.event_log)
+
+
+def test_build_completion_pays_a_wage() -> None:
+    builder = _npc(role="builder", x=0.0, z=0.0, inventory_wood=0)
+    house = House(
+        "house_1", Vec3(0.0, 0.0, 0.0), hp=60.0, max_hp=60.0,
+        state="under_construction", build_progress=9,
+    )
+    builder.build_target_house_id = "house_1"
+    world = _world([builder], houses=[house])
+
+    apply_action_effects(builder, "build", world)
+
+    assert house.state == "completed"
+    # one build tick wage plus the completion bonus.
+    assert builder.inventory_coins >= COINS_ON_BUILD_COMPLETE
+
+
+# --------------------------------------------------------------------------- #
+# Lifecycle: a child inherits nation, connector, and a sensible role
+# --------------------------------------------------------------------------- #
+def _make_two_country_world() -> WorldState:
+    return create_world(load_game_config(Path("config/game.modal.local.json")))
+
+
+def test_child_inherits_country_and_connector_from_qwen_parent() -> None:
+    world = _make_two_country_world()
+    parent = next(n for n in world.npcs if n.country_id == "qwen")
+    house = next(h for h in world.houses if h.id == "house_qwen_001")
+    parent.position = house.position
+    parent.health = 100
+    parent.hunger = 0.0
+    parent.safety = 100.0
+    parent.age = 120
+    parent.reproduction_cooldown = 0
+
+    before = {n.id for n in world.npcs}
+    _maybe_reproduce(world, parent, next_tick=10)
+    new_ids = {n.id for n in world.npcs} - before
+    assert new_ids, "expected a child to be born"
+
+    child = next(n for n in world.npcs if n.id in new_ids)
+    assert child.country_id == "qwen"
+    assert child.connector_id == "qwen"  # routed to the same model as the parent
+    assert child.unrestricted_actions == parent.unrestricted_actions
+    assert child.role in {"gatherer", "guard", "builder"}
+    # The child is registered as a citizen of its nation.
+    qwen = next(c for c in world.countries if c.id == "qwen")
+    assert child.id in qwen.citizen_ids
+
+
+def test_child_of_nemotron_parent_is_nemotron_default_connector() -> None:
+    world = _make_two_country_world()
+    parent = next(n for n in world.npcs if n.country_id == "nemotron")
+    house = next(h for h in world.houses if h.id == "house_nemotron_001")
+    parent.position = house.position
+    parent.health = 100
+    parent.hunger = 0.0
+    parent.safety = 100.0
+    parent.age = 120
+    parent.reproduction_cooldown = 0
+
+    before = {n.id for n in world.npcs}
+    _maybe_reproduce(world, parent, next_tick=10)
+    child = next(n for n in world.npcs if n.id not in before)
+
+    assert child.country_id == "nemotron"
+    assert child.connector_id is None  # default (Nemotron) connector