updated textures & refactor logic

architecture.md

@@ -424,60 +424,54 @@ Other state contracts:
 
 `Gap`: no global memory/event timeline, no relation/faction maps, no action history except per-NPC memories and UI-facing `intention`.
 
-## 9. Current Action System
+## 9. Current Action System (primitives refactor, 2026-06)
 
-`Current`: actions are represented by `ActionKind = Literal["walk", "talk", "attack", "idle"]` and `NpcDirective`.
+`Current`: the whole action surface is six parameterized primitives,
+`ActionKind = Literal["move", "speak", "strike", "use", "transfer", "idle"]`
+(`connectors/base.py`). Behavioral flavor (fleeing, pleading, threatening,
+stealing, gathering, healing...) is expressed through parameters and free-text
+intent, never through dedicated action ids:
 
-```python
-@dataclass(frozen=True, slots=True)
-class NpcDirective:
-    npc_id: str
-    action: ActionKind = "idle"
-    target: Vec3 | None = None
-    target_npc_id: str | None = None
-    message: str | None = None
-    memory: str | None = None
-```
+| Primitive | Key parameters | Covers |
+| --- | --- | --- |
+| `move` | `target` coords, `target_npc_id`/`target_entity_id`/`resource_id`, `away` | walking, pursuit, investigation, approaching resources, fleeing (`away=true`) |
+| `speak` | `target_npc_id`, `message`, `communication_intent` | direct talk, pleading, threatening, trade requests; without target it is a broadcast shout (call for help) |
+| `strike` | `target_npc_id` / `target_entity_id` | attacking NPCs and beasts |
+| `use` | `resource_id` (gather) or `resource_type` food/herbs (eat/heal) | gathering, eating, healing |
+| `transfer` | `target_npc_id`, `resource_type`, `amount`, `take` | giving resources; `take=true` is stealing |
+| `idle` | `intent` (observe/defend) | waiting, observing, defending |
+
+Design principles:
+
+- **The engine validates only physical possibility.** `validate_directive`
+  (`tick.py`) and `validate_survival_action` (`survival.py`) repair missing or
+  dead targets, out-of-range interactions (converted to approach movement), and
+  empty inventories. They never reject an action for being behaviorally
+  implausible — that judgment belongs to the planner/LLM.
+- **Hints, not masks.** `build_action_hints` (`actions/hints.py`) produces
+  ranked `suggested_actions` plus a reason from the citizen's goal and
+  perception. They are injected into the LLM prompt as hints; all six tools
+  are always available (`primitive_tools()` in `openai_compatible.py`).
+  The survival prompt equivalently uses `GOAL_SUGGESTED_ACTIONS`.
+- **The deterministic planner is an autopilot, not a pre-filter.**
+  `autopilot.py` (social worlds) and `propose_survival_tick` /
+  `survival_directive_for` (survival worlds) fill gaps when no LLM directive
+  exists or the output is unusable. They never restrict the LLM's choices.
+- **Effect resolution stays engine-owned.** Damage, hunger, inventory,
+  movement steps, and memory episodes are resolved deterministically in
+  `tick.py` / `survival.py`; inside the survival resolver primitives are
+  translated to private effect verbs (`_verb_for_action`) that never leave the
+  module.
 
 Action lifecycle:
 
-| Stage | Current Implementation |
+| Stage | Implementation |
 | --- | --- |
-| Selection | Deterministic connector or OpenAI-compatible NPC tool call. |
+| Selection | LLM picks one of six primitive tools; deterministic autopilot otherwise. |
 | Parsing | `_parse_tool_calls` / `_parse_json_content` / `_actions_to_plan`. |
-| Plan | `TickPlan.directives`. |
-| Execution | `apply_tick_plan` dispatches to `_apply_walk`, `_apply_talk`, `_apply_attack`. |
-| Consequences | Position, intention, health, memory updates. |
-| Failure states | Intention/memory strings such as `too far to attack`, `could not talk`. |
-
-Rules currently present:
-
-| Rule | File | Current |
-| --- | --- | --- |
-| Terrain clamp | `tick.py` | Walk targets clamp to half width/depth. |
-| Max walk distance | `tick.py` | Walk moves at most `MAX_WALK_DISTANCE = 4.0`. |
-| Talk range | `tick.py` | `distance_between > TALK_RADIUS` blocks talk. |
-| Attack range | `tick.py` | `distance_between > ATTACK_RADIUS` blocks damage. |
-| Dead actors | `tick.py` | Dead NPC directives ignored; intention `dead`. |
-| Dead targets | `tick.py` | Talk/attack unavailable if target not alive. |
-| Damage resolution | `tick.py` | Server computes `attack_damage + deterministic rng 0..5`. |
-| Occupancy | Tests | Multiple NPCs can occupy same position; no collision blocking. |
-
-Important gaps:
-
-| Missing Rule | Current Consequence |
-| --- | --- |
-| Intent vs execution distinction | LLM can request `attack`; executor only fails it instead of converting to pursuit. |
-| Pre-validation report | No explicit `ValidationResult` object or debug trace. |
-| Target visibility validation at execution | Parser checks target exists, but executor does not require that target was visible in actor context. |
-| Move before melee attack | Out-of-range attack becomes failure memory, not `walk` toward target. |
-| Talk willingness/availability | Hostile/attacked target can still be talked to if alive and in range. |
-| Threat proximity response | Nearby NPCs are not forced to flee/defend/call for help. |
-| Combat/social state machine | No mode that suppresses small talk during active violence. |
-| Cooldowns/action costs | None. |
-| Failure fallback policy | Invalid action often becomes deterministic random walk via fallback, not domain-aware fallback. |
-
-`Recommendation`: first add a structured action pipeline around existing `NpcDirective` rather than replacing all action code.
+| Validation | Physical-possibility repairs with `ValidationResult` debug traces. |
+| Execution | `apply_tick_plan` dispatches `_apply_move/_apply_speak/_apply_strike/_apply_idle`; survival worlds resolve through `apply_survival_plan`. |
+| Consequences | Position, intention, health, inventory, memory episode, relationship updates. |
 
 ## 10. Current Frontend Architecture
 

frontend/src/App.tsx

@@ -48,7 +48,11 @@ export function App() {
         }}
       />
 
-      <AgentPanel entity={simulation.selectedEntity} />
+      <AgentPanel
+        entity={simulation.selectedEntity}
+        beast={simulation.selectedBeast}
+        resource={simulation.selectedResource}
+      />
 
       <StatusToasts
         error={simulation.error}

frontend/src/components/AgentPanel.tsx

@@ -1,11 +1,20 @@
-import type { EntitySnapshot } from "../types";
+import type { BeastSnapshot, EntitySnapshot, ResourceNodeSnapshot } from "../types";
 import { TooltipLabel } from "./TooltipLabel";
 
 type AgentPanelProps = {
   entity: EntitySnapshot | null;
+  beast?: BeastSnapshot | null;
+  resource?: ResourceNodeSnapshot | null;
 };
 
-export function AgentPanel({ entity }: AgentPanelProps) {
+export function AgentPanel({ entity, beast = null, resource = null }: AgentPanelProps) {
+  if (beast) {
+    return <BeastPanel beast={beast} />;
+  }
+  if (resource) {
+    return <ResourcePanel resource={resource} />;
+  }
+
   const selectedName = entity?.label ?? "No NPC";
   const selectedRole = entity?.role ?? "world";
 
@@ -20,6 +29,55 @@ export function AgentPanel({ entity }: AgentPanelProps) {
   );
 }
 
+function BeastPanel({ beast }: { beast: BeastSnapshot }) {
+  const suffix = beast.id.replace(/^beast[_-]?/, "");
+  const beastName = suffix ? `Beast ${suffix}` : "Beast";
+  const healthLabel = `${beast.health} / ${beast.max_health} HP`;
+  const positionLabel = `x ${beast.position.x.toFixed(1)} / z ${beast.position.z.toFixed(1)}`;
+
+  return (
+    <aside className="agentPanel" aria-label="Selected beast">
+      <div className="panelHeader">
+        <TooltipLabel className="panelTitle" value={beastName} />
+        <TooltipLabel className="panelRole" value="beast" />
+      </div>
+      <div className="agentReadout">
+        <TooltipLabel className="readoutCell healthCell" value={healthLabel} />
+        <TooltipLabel className="readoutCell" value={beast.state} />
+        <TooltipLabel
+          className="readoutCell"
+          value={beast.target_npc_id ? `hunting ${beast.target_npc_id}` : "no target"}
+        />
+        <TooltipLabel className="readoutCell" value={positionLabel} />
+      </div>
+    </aside>
+  );
+}
+
+function ResourcePanel({ resource }: { resource: ResourceNodeSnapshot }) {
+  const title = resource.type
+    ? `${resource.type.charAt(0).toUpperCase()}${resource.type.slice(1)} node`
+    : "Resource node";
+  const amountLabel = resource.max_amount
+    ? `${resource.amount} / ${resource.max_amount}`
+    : `${resource.amount} left`;
+  const positionLabel = `x ${resource.position.x.toFixed(1)} / z ${resource.position.z.toFixed(1)}`;
+
+  return (
+    <aside className="agentPanel" aria-label="Selected resource">
+      <div className="panelHeader">
+        <TooltipLabel className="panelTitle" value={title} />
+        <TooltipLabel className="panelRole" value="resource" />
+      </div>
+      <div className="agentReadout">
+        <TooltipLabel className="readoutCell" value={amountLabel} />
+        <TooltipLabel className="readoutCell" value={resource.id} />
+        <TooltipLabel className="readoutCell" value={positionLabel} />
+      </div>
+    </aside>
+  );
+}
+
 function AgentDetails({ entity }: { entity: EntitySnapshot }) {
   return (
     <>

frontend/src/hooks/useWorldSimulation.ts

@@ -96,6 +96,16 @@ export function useWorldSimulation() {
     [selectedId, snapshot],
   );
 
+  const selectedBeast = useMemo(
+    () => snapshot?.beasts?.find((beast) => beast.id === selectedId) ?? null,
+    [selectedId, snapshot],
+  );
+
+  const selectedResource = useMemo(
+    () => snapshot?.resource_nodes?.find((node) => node.id === selectedId) ?? null,
+    [selectedId, snapshot],
+  );
+
   return {
     error,
     godCommand,
@@ -104,7 +114,9 @@ export function useWorldSimulation() {
     isGodPending,
     isWaitingForTick,
     isWorldCommandPending,
+    selectedBeast,
     selectedEntity,
+    selectedResource,
     selectedId,
     setGodCommand,
     setIsAutoTicking,
@@ -148,10 +160,14 @@ function useSelectedEntityFallback(
     }
 
     setSelectedId((currentId) => {
-      if (currentId && snapshot.entities.some((entity) => entity.id === currentId)) {
-        return currentId;
+      if (!currentId) {
+        return null;
       }
-      return snapshot.entities[0]?.id ?? null;
+      const stillExists =
+        snapshot.entities.some((entity) => entity.id === currentId) ||
+        (snapshot.beasts ?? []).some((beast) => beast.id === currentId) ||
+        (snapshot.resource_nodes ?? []).some((node) => node.id === currentId);
+      return stillExists ? currentId : null;
     });
   }, [snapshot, setSelectedId]);
 }

frontend/src/scene/BeastActor.tsx

@@ -0,0 +1,433 @@
+import { Html } from "@react-three/drei";
+import { useFrame } from "@react-three/fiber";
+import { useMemo, useRef } from "react";
+import type { Group, Mesh } from "three";
+import { MathUtils, Vector3 } from "three";
+
+import type { BeastSnapshot } from "../types";
+import { angularDistance, dampAngle, hashToUnit } from "./characterUtils";
+
+type BeastActorProps = {
+  beast: BeastSnapshot;
+  isSelected: boolean;
+  onSelect: () => void;
+};
+
+type BeastPalette = {
+  fur: string;
+  belly: string;
+  legs: string;
+  snout: string;
+  horns: string;
+  eyes: string;
+};
+
+const LIVING_PALETTE: BeastPalette = {
+  fur: "#8f2c1e",
+  belly: "#b3543a",
+  legs: "#5d2014",
+  snout: "#c97a55",
+  horns: "#3a241d",
+  eyes: "#ffd23e",
+};
+
+const DEAD_PALETTE: BeastPalette = {
+  fur: "#3d3532",
+  belly: "#4c423e",
+  legs: "#322b28",
+  snout: "#564a44",
+  horns: "#2a2421",
+  eyes: "#1f1b19",
+};
+
+export function BeastActor({ beast, isSelected, onSelect }: BeastActorProps) {
+  const groupRef = useRef<Group>(null);
+  const pulseRef = useRef<Mesh>(null);
+  const bodyRef = useRef<Group>(null);
+  const headRef = useRef<Group>(null);
+  const tailRef = useRef<Group>(null);
+  const frontLeftLegRef = useRef<Group>(null);
+  const frontRightLegRef = useRef<Group>(null);
+  const backLeftLegRef = useRef<Group>(null);
+  const backRightLegRef = useRef<Group>(null);
+  const walkBlendRef = useRef(0);
+  const moveDirection = useMemo(() => new Vector3(0, 0, 1), []);
+  const animationPhase = useMemo(() => hashToUnit(beast.id) * Math.PI * 2, [beast.id]);
+  const initialPosition = useRef<[number, number, number]>([
+    beast.position.x,
+    beast.position.y,
+    beast.position.z,
+  ]);
+
+  const isDead = beast.state === "dead";
+  const palette = isDead ? DEAD_PALETTE : LIVING_PALETTE;
+
+  useFrame((state, delta) => {
+    const group = groupRef.current;
+    if (!group) {
+      return;
+    }
+
+    const time = state.clock.elapsedTime + animationPhase;
+    const walkTarget = isDead ? 0 : updatePosition(group, beast, moveDirection, delta);
+    walkBlendRef.current = MathUtils.damp(walkBlendRef.current, walkTarget, 7, delta);
+
+    if (pulseRef.current) {
+      const pulse = 1 + Math.sin(state.clock.elapsedTime * 4) * 0.08;
+      pulseRef.current.scale.setScalar(isSelected ? pulse : 0.001);
+    }
+
+    if (isDead) {
+      animateDeath(
+        bodyRef.current,
+        [frontLeftLegRef, frontRightLegRef, backLeftLegRef, backRightLegRef],
+        delta,
+      );
+      return;
+    }
+
+    animateGait({
+      time,
+      delta,
+      walkBlend: walkBlendRef.current,
+      isAttacking: beast.state === "attacking",
+      body: bodyRef.current,
+      head: headRef.current,
+      tail: tailRef.current,
+      frontLeft: frontLeftLegRef.current,
+      frontRight: frontRightLegRef.current,
+      backLeft: backLeftLegRef.current,
+      backRight: backRightLegRef.current,
+    });
+  });
+
+  const beastName = useMemo(() => {
+    const suffix = beast.id.replace(/^beast[_-]?/, "");
+    return suffix ? `Beast ${suffix}` : "Beast";
+  }, [beast.id]);
+
+  return (
+    <group ref={groupRef} position={initialPosition.current}>
+      <mesh
+        ref={pulseRef}
+        position={[0, 0.035, 0]}
+        rotation={[-Math.PI / 2, 0, 0]}
+        onClick={(event) => {
+          event.stopPropagation();
+          onSelect();
+        }}
+      >
+        <ringGeometry args={[0.95, 1.35, 40]} />
+        <meshBasicMaterial color="#ff7a5c" transparent opacity={0.72} />
+      </mesh>
+      <mesh rotation={[-Math.PI / 2, 0, 0]} position={[0, 0.04, 0]}>
+        <ringGeometry args={[0.85, 1.12, 28]} />
+        <meshBasicMaterial color="#ffb09c" transparent opacity={isDead ? 0.18 : 0.45} />
+      </mesh>
+      <BeastBody
+        bodyRef={bodyRef}
+        headRef={headRef}
+        tailRef={tailRef}
+        legRefs={{
+          frontLeft: frontLeftLegRef,
+          frontRight: frontRightLegRef,
+          backLeft: backLeftLegRef,
+          backRight: backRightLegRef,
+        }}
+        palette={palette}
+        onSelect={onSelect}
+      />
+      <Html
+        center
+        distanceFactor={24}
+        position={[0, 2.45, 0]}
+        className="npcLabel"
+        zIndexRange={[8, 0]}
+      >
+        <button
+          type="button"
+          onClick={(event) => {
+            // Keep the click out of the r3f event container, where it would
+            // raycast into empty space and fire onPointerMissed (deselect).
+            event.stopPropagation();
+            onSelect();
+          }}
+          aria-label={`Select ${beastName}`}
+        >
+          <strong>{beastName}</strong>
+          <span>{beast.state}</span>
+        </button>
+      </Html>
+    </group>
+  );
+}
+
+function updatePosition(
+  group: Group,
+  beast: BeastSnapshot,
+  moveDirection: Vector3,
+  delta: number,
+): number {
+  group.position.y = MathUtils.damp(group.position.y, beast.position.y, 8, delta);
+
+  const deltaX = beast.position.x - group.position.x;
+  const deltaZ = beast.position.z - group.position.z;
+  const distanceToTarget = Math.hypot(deltaX, deltaZ);
+  if (distanceToTarget <= 0.025) {
+    group.position.x = beast.position.x;
+    group.position.z = beast.position.z;
+    return 0;
+  }
+
+  moveDirection.set(deltaX / distanceToTarget, 0, deltaZ / distanceToTarget);
+  const desiredRotation = Math.atan2(moveDirection.x, moveDirection.z);
+  const rotationDelta = angularDistance(group.rotation.y, desiredRotation);
+  const alignment = MathUtils.clamp(1 - rotationDelta / (Math.PI * 0.62), 0, 1);
+  const distanceBlend = MathUtils.clamp(distanceToTarget / 0.45, 0, 1);
+  const movementBlend = distanceBlend * MathUtils.lerp(0.2, 1, alignment);
+  const step = Math.min(distanceToTarget, 2.1 * MathUtils.lerp(0.18, 1, movementBlend) * delta);
+
+  group.position.x += moveDirection.x * step;
+  group.position.z += moveDirection.z * step;
+  group.rotation.y = dampAngle(group.rotation.y, desiredRotation, 5.5, delta);
+  return movementBlend;
+}
+
+type GaitOptions = {
+  time: number;
+  delta: number;
+  walkBlend: number;
+  isAttacking: boolean;
+  body: Group | null;
+  head: Group | null;
+  tail: Group | null;
+  frontLeft: Group | null;
+  frontRight: Group | null;
+  backLeft: Group | null;
+  backRight: Group | null;
+};
+
+function animateGait(options: GaitOptions) {
+  const { time, delta, walkBlend, isAttacking, body, head, tail } = options;
+  const stride = Math.sin(time * 8.4) * walkBlend;
+  const counterStride = Math.sin(time * 8.4 + Math.PI) * walkBlend;
+  const breathing = Math.sin(time * 2.4) * 0.02;
+
+  if (body) {
+    body.position.y = MathUtils.damp(
+      body.position.y,
+      Math.abs(stride) * 0.06 + breathing,
+      10,
+      delta,
+    );
+    body.rotation.z = MathUtils.damp(body.rotation.z, 0, 6, delta);
+    body.rotation.x = MathUtils.damp(
+      body.rotation.x,
+      isAttacking ? Math.sin(time * 11) * 0.07 - 0.06 : Math.sin(time * 8.4) * 0.022 * walkBlend,
+      8,
+      delta,
+    );
+  }
+  if (head) {
+    const sniff = Math.sin(time * 3.4) * 0.05 * (1 - walkBlend);
+    head.rotation.x = isAttacking ? Math.sin(time * 11) * 0.22 + 0.12 : sniff;
+    head.rotation.y = Math.sin(time * 2.2) * 0.08 * (1 - walkBlend);
+  }
+  if (tail) {
+    const wagSpeed = isAttacking ? 14 : 3.2 + walkBlend * 5;
+    tail.rotation.y = Math.sin(time * wagSpeed) * (0.28 + walkBlend * 0.14);
+    tail.rotation.x = 0.55 + Math.sin(time * 2.6) * 0.06;
+  }
+
+  setLegSwing(options.frontLeft, stride);
+  setLegSwing(options.backRight, stride);
+  setLegSwing(options.frontRight, counterStride);
+  setLegSwing(options.backLeft, counterStride);
+}
+
+function setLegSwing(leg: Group | null, stride: number) {
+  if (leg) {
+    leg.rotation.x = stride * 0.58;
+  }
+}
+
+function animateDeath(
+  body: Group | null,
+  legRefs: React.RefObject<Group | null>[],
+  delta: number,
+) {
+  if (body) {
+    body.rotation.z = MathUtils.damp(body.rotation.z, Math.PI / 2, 4, delta);
+    body.rotation.x = MathUtils.damp(body.rotation.x, 0, 4, delta);
+    body.position.y = MathUtils.damp(body.position.y, -0.34, 4, delta);
+  }
+  legRefs.forEach((legRef, index) => {
+    if (legRef.current) {
+      const splay = index % 2 === 0 ? 0.3 : -0.25;
+      legRef.current.rotation.x = MathUtils.damp(legRef.current.rotation.x, splay, 4, delta);
+    }
+  });
+}
+
+type BeastLegRefs = {
+  frontLeft: React.RefObject<Group | null>;
+  frontRight: React.RefObject<Group | null>;
+  backLeft: React.RefObject<Group | null>;
+  backRight: React.RefObject<Group | null>;
+};
+
+type BeastBodyProps = {
+  bodyRef: React.RefObject<Group | null>;
+  headRef: React.RefObject<Group | null>;
+  tailRef: React.RefObject<Group | null>;
+  legRefs: BeastLegRefs;
+  palette: BeastPalette;
+  onSelect: () => void;
+};
+
+function BeastBody({ bodyRef, headRef, tailRef, legRefs, palette, onSelect }: BeastBodyProps) {
+  return (
+    <group
+      ref={bodyRef}
+      onClick={(event) => {
+        event.stopPropagation();
+        onSelect();
+      }}
+    >
+      {/* torso */}
+      <mesh castShadow receiveShadow position={[0, 0.84, -0.1]}>
+        <boxGeometry args={[0.92, 0.6, 1.4]} />
+        <meshStandardMaterial color={palette.fur} roughness={0.85} />
+      </mesh>
+      {/* chest */}
+      <mesh castShadow position={[0, 0.88, 0.48]}>
+        <boxGeometry args={[1.04, 0.72, 0.58]} />
+        <meshStandardMaterial color={palette.fur} roughness={0.85} />
+      </mesh>
+      {/* belly */}
+      <mesh castShadow position={[0, 0.6, -0.05]}>
+        <boxGeometry args={[0.78, 0.22, 1.18]} />
+        <meshStandardMaterial color={palette.belly} roughness={0.88} />
+      </mesh>
+      {/* hips */}
+      <mesh castShadow position={[0, 0.82, -0.78]}>
+        <boxGeometry args={[0.82, 0.54, 0.44]} />
+        <meshStandardMaterial color={palette.fur} roughness={0.85} />
+      </mesh>
+      {/* back spikes */}
+      <mesh castShadow position={[0, 1.22, -0.15]}>
+        <boxGeometry args={[0.16, 0.18, 0.16]} />
+        <meshStandardMaterial color={palette.horns} roughness={0.7} />
+      </mesh>
+      <mesh castShadow position={[0, 1.2, -0.55]}>
+        <boxGeometry args={[0.14, 0.14, 0.14]} />
+        <meshStandardMaterial color={palette.horns} roughness={0.7} />
+      </mesh>
+
+      <BeastHead headRef={headRef} palette={palette} />
+
+      {/* tail */}
+      <group ref={tailRef} position={[0, 0.96, -0.98]} rotation={[0.55, 0, 0]}>
+        <mesh castShadow position={[0, 0, -0.26]}>
+          <boxGeometry args={[0.16, 0.16, 0.52]} />
+          <meshStandardMaterial color={palette.fur} roughness={0.85} />
+        </mesh>
+        <mesh castShadow position={[0, 0, -0.56]}>
+          <boxGeometry args={[0.22, 0.22, 0.16]} />
+          <meshStandardMaterial color={palette.horns} roughness={0.75} />
+        </mesh>
+      </group>
+
+      <BeastLeg legRef={legRefs.frontLeft} x={-0.34} z={0.48} palette={palette} />
+      <BeastLeg legRef={legRefs.frontRight} x={0.34} z={0.48} palette={palette} />
+      <BeastLeg legRef={legRefs.backLeft} x={-0.3} z={-0.72} palette={palette} />
+      <BeastLeg legRef={legRefs.backRight} x={0.3} z={-0.72} palette={palette} />
+    </group>
+  );
+}
+
+function BeastHead({
+  headRef,
+  palette,
+}: {
+  headRef: React.RefObject<Group | null>;
+  palette: BeastPalette;
+}) {
+  return (
+    <group ref={headRef} position={[0, 1.12, 0.92]}>
+      {/* skull */}
+      <mesh castShadow>
+        <boxGeometry args={[0.62, 0.54, 0.52]} />
+        <meshStandardMaterial color={palette.fur} roughness={0.82} />
+      </mesh>
+      {/* snout */}
+      <mesh castShadow position={[0, -0.1, 0.38]}>
+        <boxGeometry args={[0.36, 0.26, 0.34]} />
+        <meshStandardMaterial color={palette.snout} roughness={0.85} />
+      </mesh>
+      {/* nose */}
+      <mesh castShadow position={[0, -0.04, 0.56]}>
+        <boxGeometry args={[0.16, 0.1, 0.06]} />
+        <meshStandardMaterial color={palette.horns} roughness={0.6} />
+      </mesh>
+      {/* jaw */}
+      <mesh castShadow position={[0, -0.24, 0.32]}>
+        <boxGeometry args={[0.3, 0.08, 0.26]} />
+        <meshStandardMaterial color={palette.belly} roughness={0.85} />
+      </mesh>
+      {/* ears */}
+      <mesh castShadow position={[-0.22, 0.36, -0.08]} rotation={[0, 0, 0.18]}>
+        <boxGeometry args={[0.14, 0.24, 0.1]} />
+        <meshStandardMaterial color={palette.horns} roughness={0.75} />
+      </mesh>
+      <mesh castShadow position={[0.22, 0.36, -0.08]} rotation={[0, 0, -0.18]}>
+        <boxGeometry args={[0.14, 0.24, 0.1]} />
+        <meshStandardMaterial color={palette.horns} roughness={0.75} />
+      </mesh>
+      {/* eyes */}
+      <mesh position={[-0.17, 0.08, 0.27]}>
+        <boxGeometry args={[0.1, 0.08, 0.04]} />
+        <meshStandardMaterial
+          color={palette.eyes}
+          emissive={palette.eyes}
+          emissiveIntensity={0.9}
+          roughness={0.3}
+        />
+      </mesh>
+      <mesh position={[0.17, 0.08, 0.27]}>
+        <boxGeometry args={[0.1, 0.08, 0.04]} />
+        <meshStandardMaterial
+          color={palette.eyes}
+          emissive={palette.eyes}
+          emissiveIntensity={0.9}
+          roughness={0.3}
+        />
+      </mesh>
+    </group>
+  );
+}
+
+function BeastLeg({
+  legRef,
+  x,
+  z,
+  palette,
+}: {
+  legRef: React.RefObject<Group | null>;
+  x: number;
+  z: number;
+  palette: BeastPalette;
+}) {
+  return (
+    <group ref={legRef} position={[x, 0.62, z]}>
+      <mesh castShadow position={[0, -0.3, 0]}>
+        <boxGeometry args={[0.22, 0.5, 0.24]} />
+        <meshStandardMaterial color={palette.legs} roughness={0.85} />
+      </mesh>
+      <mesh castShadow position={[0, -0.56, 0.04]}>
+        <boxGeometry args={[0.26, 0.12, 0.3]} />
+        <meshStandardMaterial color={palette.horns} roughness={0.8} />
+      </mesh>
+    </group>
+  );
+}

frontend/src/scene/GodSimulatorScene.tsx

@@ -8,7 +8,7 @@ import { WorldView } from "./WorldView";
 type GodSimulatorSceneProps = {
   snapshot: WorldSnapshot | null;
   selectedId: string | null;
-  onSelectEntity: (id: string) => void;
+  onSelectEntity: (id: string | null) => void;
 };
 
 export function GodSimulatorScene({
@@ -23,6 +23,11 @@ export function GodSimulatorScene({
       camera={{ position: [34, 38, 42], fov: 45, near: 0.1, far: 300 }}
       dpr={[1, 1.75]}
       gl={{ preserveDrawingBuffer: true }}
+      onPointerMissed={(event) => {
+        if (event.type === "click") {
+          onSelectEntity(null);
+        }
+      }}
     >
       <color attach="background" args={["#b9d7f2"]} />
       <fog attach="fog" args={["#b9d7f2", 70, 165]} />
@@ -56,9 +61,15 @@ export function GodSimulatorScene({
 
 function LoadingTerrain() {
   return (
-    <mesh rotation={[-Math.PI / 2, 0, 0]}>
-      <planeGeometry args={[80, 80, 1, 1]} />
-      <meshStandardMaterial color="#43a047" roughness={0.85} />
-    </mesh>
+    <group>
+      <mesh position={[0, -0.3, 0]}>
+        <boxGeometry args={[80, 0.6, 80]} />
+        <meshStandardMaterial color="#43a047" roughness={0.85} />
+      </mesh>
+      <mesh position={[0, -1.3, 0]}>
+        <boxGeometry args={[80, 1.6, 80]} />
+        <meshStandardMaterial color="#6b4a2c" roughness={0.95} />
+      </mesh>
+    </group>
   );
 }

frontend/src/scene/NpcBody.tsx

@@ -35,8 +35,8 @@ export function NpcBody({ refs, palette, onSelect }: NpcBodyProps) {
       <NpcTorso torsoRef={refs.torsoRef} palette={palette} />
       <NpcArm side="left" armRef={refs.leftArmRef} palette={palette} />
       <NpcArm side="right" armRef={refs.rightArmRef} palette={palette} />
-      <mesh castShadow position={[0, 1.66, 0]} rotation={[Math.PI / 2, 0, 0]}>
-        <torusGeometry args={[0.22, 0.035, 8, 26]} />
+      <mesh castShadow position={[0, 1.64, 0]}>
+        <boxGeometry args={[0.5, 0.08, 0.42]} />
         <meshStandardMaterial color={palette.accent} roughness={0.5} />
       </mesh>
       <NpcHead headRef={refs.headRef} palette={palette} />
@@ -55,12 +55,12 @@ function NpcLeg({ side, legRef, palette }: LimbProps & { legRef: RefObject<Group
   return (
     <group ref={legRef} position={[x, 0.78, 0]}>
       <mesh castShadow position={[0, -0.28, 0.02]}>
-        <capsuleGeometry args={[0.075, 0.48, 5, 12]} />
-        <meshStandardMaterial color={palette.legs} roughness={0.68} />
+        <boxGeometry args={[0.2, 0.56, 0.22]} />
+        <meshStandardMaterial color={palette.legs} roughness={0.78} />
       </mesh>
-      <mesh castShadow position={[0, -0.59, 0.08]} scale={[0.92, 0.42, 1.25]}>
-        <sphereGeometry args={[0.13, 12, 12]} />
-        <meshStandardMaterial color="#342f2c" roughness={0.72} />
+      <mesh castShadow position={[0, -0.62, 0.06]}>
+        <boxGeometry args={[0.22, 0.14, 0.32]} />
+        <meshStandardMaterial color="#342f2c" roughness={0.8} />
       </mesh>
     </group>
   );
@@ -72,12 +72,12 @@ function NpcArm({ side, armRef, palette }: LimbProps & { armRef: RefObject<Group
   return (
     <group ref={armRef} position={[x, 1.5, 0.02]}>
       <mesh castShadow position={[0, -0.32, 0]}>
-        <capsuleGeometry args={[0.065, 0.52, 5, 12]} />
-        <meshStandardMaterial color={palette.sleeves} roughness={0.62} />
+        <boxGeometry args={[0.16, 0.58, 0.18]} />
+        <meshStandardMaterial color={palette.sleeves} roughness={0.74} />
       </mesh>
-      <mesh castShadow position={[0, -0.63, 0.02]}>
-        <sphereGeometry args={[0.09, 12, 12]} />
-        <meshStandardMaterial color="#f7c89b" roughness={0.62} />
+      <mesh castShadow position={[0, -0.66, 0.01]}>
+        <boxGeometry args={[0.15, 0.14, 0.16]} />
+        <meshStandardMaterial color="#f7c89b" roughness={0.7} />
       </mesh>
     </group>
   );

frontend/src/scene/NpcHead.tsx

@@ -11,32 +11,42 @@ type NpcHeadProps = {
 export function NpcHead({ headRef, palette }: NpcHeadProps) {
   return (
     <group ref={headRef} position={[0, 1.94, 0]}>
+      {/* skull */}
       <mesh castShadow>
-        <sphereGeometry args={[0.29, 20, 20]} />
-        <meshStandardMaterial color="#f7c89b" roughness={0.58} />
+        <boxGeometry args={[0.46, 0.44, 0.44]} />
+        <meshStandardMaterial color="#f7c89b" roughness={0.7} />
       </mesh>
-      <mesh castShadow position={[0, 0.18, -0.01]} scale={[1, 0.52, 1]}>
-        <sphereGeometry args={[0.3, 18, 18]} />
-        <meshStandardMaterial color={palette.hair} roughness={0.72} />
+      {/* hair cap */}
+      <mesh castShadow position={[0, 0.21, -0.02]}>
+        <boxGeometry args={[0.5, 0.18, 0.48]} />
+        <meshStandardMaterial color={palette.hair} roughness={0.78} />
       </mesh>
-      <mesh castShadow position={[0, 0.25, 0.12]} rotation={[0.2, 0, 0]}>
-        <cylinderGeometry args={[0.27, 0.29, 0.12, 18]} />
-        <meshStandardMaterial color={palette.accent} roughness={0.56} />
+      <mesh castShadow position={[0, 0.04, -0.22]}>
+        <boxGeometry args={[0.5, 0.34, 0.08]} />
+        <meshStandardMaterial color={palette.hair} roughness={0.78} />
       </mesh>
-      <mesh castShadow position={[0, 0.2, 0.34]} scale={[1.3, 0.26, 0.54]}>
-        <sphereGeometry args={[0.16, 12, 12]} />
+      {/* headband */}
+      <mesh castShadow position={[0, 0.13, 0.02]}>
+        <boxGeometry args={[0.52, 0.07, 0.5]} />
         <meshStandardMaterial color={palette.accent} roughness={0.56} />
       </mesh>
-      <mesh position={[-0.09, 0.03, 0.27]}>
-        <sphereGeometry args={[0.025, 8, 8]} />
+      {/* eyes */}
+      <mesh position={[-0.11, 0.02, 0.225]}>
+        <boxGeometry args={[0.07, 0.07, 0.02]} />
         <meshStandardMaterial color="#23231f" roughness={0.4} />
       </mesh>
-      <mesh position={[0.09, 0.03, 0.27]}>
-        <sphereGeometry args={[0.025, 8, 8]} />
+      <mesh position={[0.11, 0.02, 0.225]}>
+        <boxGeometry args={[0.07, 0.07, 0.02]} />
         <meshStandardMaterial color="#23231f" roughness={0.4} />
       </mesh>
-      <mesh position={[0, -0.085, 0.285]} scale={[1, 0.35, 0.2]}>
-        <boxGeometry args={[0.13, 0.018, 0.018]} />
+      {/* nose */}
+      <mesh castShadow position={[0, -0.06, 0.24]}>
+        <boxGeometry args={[0.08, 0.1, 0.06]} />
+        <meshStandardMaterial color="#eab184" roughness={0.7} />
+      </mesh>
+      {/* mouth */}
+      <mesh position={[0, -0.15, 0.225]}>
+        <boxGeometry args={[0.14, 0.03, 0.02]} />
         <meshStandardMaterial color="#7d4a39" roughness={0.55} />
       </mesh>
     </group>

frontend/src/scene/NpcLabelButton.tsx

@@ -54,7 +54,12 @@ export function NpcLabelButton({ entity, onSelect }: NpcLabelButtonProps) {
     <button
       ref={buttonRef}
       type="button"
-      onClick={onSelect}
+      onClick={(event) => {
+        // Keep the click out of the r3f event container, where it would
+        // raycast into empty space and fire onPointerMissed (deselect).
+        event.stopPropagation();
+        onSelect();
+      }}
       aria-label={`Select ${entity.label}`}
       data-tooltip={isCollapsed ? `${entity.label}: ${entity.state.intention}` : undefined}
     >

frontend/src/scene/NpcTorso.tsx

@@ -12,20 +12,28 @@ export function NpcTorso({ torsoRef, palette }: NpcTorsoProps) {
   return (
     <group ref={torsoRef} position={[0, 1.18, 0]}>
       <mesh castShadow>
-        <capsuleGeometry args={[0.31, 0.72, 8, 18]} />
-        <meshStandardMaterial color={palette.coat} roughness={0.58} />
+        <boxGeometry args={[0.58, 0.78, 0.36]} />
+        <meshStandardMaterial color={palette.coat} roughness={0.72} />
       </mesh>
-      <mesh castShadow position={[0, 0.03, 0.305]} scale={[0.72, 0.88, 0.08]}>
-        <boxGeometry args={[0.5, 0.82, 0.08]} />
-        <meshStandardMaterial color={palette.front} roughness={0.64} />
+      {/* shoulders */}
+      <mesh castShadow position={[0, 0.32, 0]}>
+        <boxGeometry args={[0.68, 0.16, 0.4]} />
+        <meshStandardMaterial color={palette.coat} roughness={0.72} />
       </mesh>
-      <mesh castShadow position={[0, 0.32, 0.36]} scale={[0.86, 0.34, 0.12]}>
-        <boxGeometry args={[0.38, 0.16, 0.08]} />
-        <meshStandardMaterial color={palette.accent} roughness={0.5} />
+      {/* front panel */}
+      <mesh castShadow position={[0, 0.02, 0.2]}>
+        <boxGeometry args={[0.4, 0.66, 0.04]} />
+        <meshStandardMaterial color={palette.front} roughness={0.74} />
       </mesh>
-      <mesh castShadow position={[0, -0.06, 0.365]} scale={[0.5, 0.5, 0.12]}>
-        <sphereGeometry args={[0.08, 12, 12]} />
-        <meshStandardMaterial color="#f8df6b" roughness={0.42} />
+      {/* belt */}
+      <mesh castShadow position={[0, -0.34, 0]}>
+        <boxGeometry args={[0.6, 0.12, 0.38]} />
+        <meshStandardMaterial color={palette.accent} roughness={0.6} />
+      </mesh>
+      {/* buckle */}
+      <mesh castShadow position={[0, -0.34, 0.2]}>
+        <boxGeometry args={[0.14, 0.1, 0.04]} />
+        <meshStandardMaterial color="#f8df6b" roughness={0.45} />
       </mesh>
     </group>
   );

frontend/src/scene/ResourceActor.tsx

@@ -0,0 +1,294 @@
+import { Html } from "@react-three/drei";
+import { useFrame } from "@react-three/fiber";
+import { useMemo, useRef } from "react";
+import type { Group, Mesh } from "three";
+import { MathUtils } from "three";
+
+import type { ResourceNodeSnapshot } from "../types";
+import { hashToUnit } from "./characterUtils";
+
+type ResourceActorProps = {
+  node: ResourceNodeSnapshot;
+  isSelected: boolean;
+  onSelect: () => void;
+};
+
+export function ResourceActor({ node, isSelected, onSelect }: ResourceActorProps) {
+  const pulseRef = useRef<Mesh>(null);
+  const swayRef = useRef<Group>(null);
+  const animationPhase = useMemo(() => hashToUnit(node.id) * Math.PI * 2, [node.id]);
+  const color = resourceColor(node.type);
+  const richness = resourceRichness(node);
+
+  useFrame((state) => {
+    const time = state.clock.elapsedTime + animationPhase;
+    if (pulseRef.current) {
+      const pulse = 1 + Math.sin(state.clock.elapsedTime * 4) * 0.08;
+      pulseRef.current.scale.setScalar(isSelected ? pulse : 0.001);
+    }
+    if (swayRef.current) {
+      swayRef.current.rotation.z = Math.sin(time * 1.4) * 0.035;
+      swayRef.current.rotation.x = Math.sin(time * 1.1) * 0.025;
+    }
+  });
+
+  return (
+    <group position={[node.position.x, node.position.y, node.position.z]}>
+      <mesh
+        ref={pulseRef}
+        position={[0, 0.035, 0]}
+        rotation={[-Math.PI / 2, 0, 0]}
+        onClick={(event) => {
+          event.stopPropagation();
+          onSelect();
+        }}
+      >
+        <ringGeometry args={[0.78, 1.1, 40]} />
+        <meshBasicMaterial color={color} transparent opacity={0.78} />
+      </mesh>
+      <mesh rotation={[-Math.PI / 2, 0, 0]} position={[0, 0.025, 0]}>
+        <ringGeometry args={[0.55, 0.72, 20]} />
+        <meshBasicMaterial color={color} transparent opacity={0.4} />
+      </mesh>
+      <group
+        scale={[richness, richness, richness]}
+        onClick={(event) => {
+          event.stopPropagation();
+          onSelect();
+        }}
+      >
+        <ResourceModel type={node.type} swayRef={swayRef} />
+      </group>
+      <Html
+        center
+        distanceFactor={24}
+        position={[0, 2.05, 0]}
+        className="npcLabel"
+        zIndexRange={[6, 0]}
+      >
+        <button
+          type="button"
+          onClick={(event) => {
+            // Keep the click out of the r3f event container, where it would
+            // raycast into empty space and fire onPointerMissed (deselect).
+            event.stopPropagation();
+            onSelect();
+          }}
+          aria-label={`Select ${node.type} node`}
+        >
+          <strong>{resourceTitle(node.type)}</strong>
+          <span>{node.amount} left</span>
+        </button>
+      </Html>
+    </group>
+  );
+}
+
+function ResourceModel({
+  type,
+  swayRef,
+}: {
+  type: string;
+  swayRef: React.RefObject<Group | null>;
+}) {
+  if (type === "food") {
+    return <BerryBush swayRef={swayRef} />;
+  }
+  if (type === "herbs") {
+    return <HerbPatch swayRef={swayRef} />;
+  }
+  if (type === "wood") {
+    return <LogPile />;
+  }
+  if (type === "weapon") {
+    return <WeaponCache />;
+  }
+  return <SupplyCrate />;
+}
+
+function BerryBush({ swayRef }: { swayRef: React.RefObject<Group | null> }) {
+  return (
+    <group>
+      {/* trunk stub */}
+      <mesh castShadow position={[0, 0.16, 0]}>
+        <boxGeometry args={[0.22, 0.32, 0.22]} />
+        <meshStandardMaterial color="#6b4a2c" roughness={0.9} />
+      </mesh>
+      <group ref={swayRef} position={[0, 0.32, 0]}>
+        {/* foliage blocks */}
+        <mesh castShadow position={[0, 0.34, 0]}>
+          <boxGeometry args={[0.92, 0.62, 0.92]} />
+          <meshStandardMaterial color="#4e8f3e" roughness={0.88} />
+        </mesh>
+        <mesh castShadow position={[0.3, 0.72, 0.12]}>
+          <boxGeometry args={[0.5, 0.4, 0.5]} />
+          <meshStandardMaterial color="#5fa84a" roughness={0.88} />
+        </mesh>
+        <mesh castShadow position={[-0.28, 0.66, -0.18]}>
+          <boxGeometry args={[0.44, 0.36, 0.44]} />
+          <meshStandardMaterial color="#5fa84a" roughness={0.88} />
+        </mesh>
+        {/* berries */}
+        <Berry x={0.32} y={0.42} z={0.42} />
+        <Berry x={-0.34} y={0.3} z={0.36} />
+        <Berry x={0.42} y={0.26} z={-0.26} />
+        <Berry x={-0.18} y={0.52} z={-0.4} />
+        <Berry x={0.05} y={0.78} z={0.3} />
+      </group>
+    </group>
+  );
+}
+
+function Berry({ x, y, z }: { x: number; y: number; z: number }) {
+  return (
+    <mesh castShadow position={[x, y, z]}>
+      <boxGeometry args={[0.14, 0.14, 0.14]} />
+      <meshStandardMaterial color="#d8453e" roughness={0.55} />
+    </mesh>
+  );
+}
+
+function HerbPatch({ swayRef }: { swayRef: React.RefObject<Group | null> }) {
+  return (
+    <group>
+      {/* dirt mound */}
+      <mesh receiveShadow castShadow position={[0, 0.07, 0]}>
+        <boxGeometry args={[1.05, 0.14, 1.05]} />
+        <meshStandardMaterial color="#5e4630" roughness={0.95} />
+      </mesh>
+      <group ref={swayRef} position={[0, 0.14, 0]}>
+        <HerbSprout x={-0.28} z={-0.2} height={0.52} />
+        <HerbSprout x={0.26} z={-0.28} height={0.42} />
+        <HerbSprout x={0.05} z={0.27} height={0.6} />
+        <HerbSprout x={-0.3} z={0.3} height={0.36} />
+      </group>
+    </group>
+  );
+}
+
+function HerbSprout({ x, z, height }: { x: number; z: number; height: number }) {
+  return (
+    <group position={[x, 0, z]}>
+      <mesh castShadow position={[0, height / 2, 0]}>
+        <boxGeometry args={[0.08, height, 0.08]} />
+        <meshStandardMaterial color="#3f7a3c" roughness={0.85} />
+      </mesh>
+      <mesh castShadow position={[0, height + 0.08, 0]}>
+        <boxGeometry args={[0.24, 0.16, 0.24]} />
+        <meshStandardMaterial color="#7cc96d" roughness={0.8} />
+      </mesh>
+    </group>
+  );
+}
+
+function LogPile() {
+  return (
+    <group>
+      <Log x={-0.24} y={0.16} rotationY={0.06} />
+      <Log x={0.26} y={0.16} rotationY={-0.04} />
+      <Log x={0} y={0.46} rotationY={0.02} />
+    </group>
+  );
+}
+
+function Log({ x, y, rotationY }: { x: number; y: number; rotationY: number }) {
+  return (
+    <group position={[x, y, 0]} rotation={[0, rotationY, 0]}>
+      <mesh castShadow receiveShadow>
+        <boxGeometry args={[0.3, 0.3, 1.1]} />
+        <meshStandardMaterial color="#6b4a2c" roughness={0.9} />
+      </mesh>
+      <mesh position={[0, 0, 0.56]}>
+        <boxGeometry args={[0.24, 0.24, 0.03]} />
+        <meshStandardMaterial color="#c9a76a" roughness={0.8} />
+      </mesh>
+      <mesh position={[0, 0, -0.56]}>
+        <boxGeometry args={[0.24, 0.24, 0.03]} />
+        <meshStandardMaterial color="#c9a76a" roughness={0.8} />
+      </mesh>
+    </group>
+  );
+}
+
+function WeaponCache() {
+  return (
+    <group>
+      {/* stone block */}
+      <mesh castShadow receiveShadow position={[0, 0.2, 0]}>
+        <boxGeometry args={[0.85, 0.4, 0.7]} />
+        <meshStandardMaterial color="#7c8089" roughness={0.9} />
+      </mesh>
+      {/* sword blade */}
+      <group position={[0, 0.4, 0]} rotation={[0, 0.5, 0.16]}>
+        <mesh castShadow position={[0, 0.5, 0]}>
+          <boxGeometry args={[0.1, 0.85, 0.05]} />
+          <meshStandardMaterial color="#d7dde6" roughness={0.3} metalness={0.6} />
+        </mesh>
+        <mesh castShadow position={[0, 0.92, 0]}>
+          <boxGeometry args={[0.34, 0.09, 0.09]} />
+          <meshStandardMaterial color="#8a6b35" roughness={0.6} />
+        </mesh>
+        <mesh castShadow position={[0, 1.08, 0]}>
+          <boxGeometry args={[0.09, 0.24, 0.09]} />
+          <meshStandardMaterial color="#5c4322" roughness={0.7} />
+        </mesh>
+      </group>
+      {/* axe leaning on the stone */}
+      <group position={[0.42, 0.32, 0.18]} rotation={[0, 0, -0.45]}>
+        <mesh castShadow position={[0, 0.3, 0]}>
+          <boxGeometry args={[0.07, 0.62, 0.07]} />
+          <meshStandardMaterial color="#5c4322" roughness={0.7} />
+        </mesh>
+        <mesh castShadow position={[0.1, 0.56, 0]}>
+          <boxGeometry args={[0.26, 0.18, 0.06]} />
+          <meshStandardMaterial color="#b7bec8" roughness={0.35} metalness={0.55} />
+        </mesh>
+      </group>
+    </group>
+  );
+}
+
+function SupplyCrate() {
+  return (
+    <group>
+      <mesh castShadow receiveShadow position={[0, 0.3, 0]}>
+        <boxGeometry args={[0.7, 0.6, 0.7]} />
+        <meshStandardMaterial color="#a98c52" roughness={0.85} />
+      </mesh>
+      <mesh castShadow position={[0, 0.62, 0]}>
+        <boxGeometry args={[0.76, 0.08, 0.76]} />
+        <meshStandardMaterial color="#7d6437" roughness={0.85} />
+      </mesh>
+    </group>
+  );
+}
+
+export function resourceTitle(type: string): string {
+  if (!type) {
+    return "Resource";
+  }
+  return `${type.charAt(0).toUpperCase()}${type.slice(1)}`;
+}
+
+export function resourceColor(type: string): string {
+  if (type === "food") {
+    return "#e3c454";
+  }
+  if (type === "herbs") {
+    return "#58a65c";
+  }
+  if (type === "wood") {
+    return "#7a5234";
+  }
+  if (type === "weapon") {
+    return "#b7bec8";
+  }
+  return "#d9d2aa";
+}
+
+function resourceRichness(node: ResourceNodeSnapshot): number {
+  const ratio = node.max_amount
+    ? MathUtils.clamp(node.amount / node.max_amount, 0, 1)
+    : MathUtils.clamp(node.amount / 10, 0, 1);
+  return MathUtils.lerp(0.55, 1.15, ratio);
+}

frontend/src/scene/WorldView.tsx

@@ -1,5 +1,11 @@
-import type { BeastSnapshot, ResourceNodeSnapshot, WorldSnapshot } from "../types";
+import { useLayoutEffect, useRef } from "react";
+import { Color, Matrix4 } from "three";
+import type { InstancedMesh } from "three";
+
+import type { WorldSnapshot } from "../types";
+import { BeastActor } from "./BeastActor";
 import { NpcActor } from "./NpcActor";
+import { ResourceActor } from "./ResourceActor";
 
 type WorldViewProps = {
   snapshot: WorldSnapshot;
@@ -8,9 +14,6 @@ type WorldViewProps = {
 };
 
 export function WorldView({ snapshot, selectedId, onSelectEntity }: WorldViewProps) {
-  const gridSize = Math.max(snapshot.terrain.width, snapshot.terrain.depth);
-  const gridDivisions = snapshot.terrain.grid_blocks;
-
   return (
     <group>
       <Terrain
@@ -18,10 +21,6 @@ export function WorldView({ snapshot, selectedId, onSelectEntity }: WorldViewPro
         depth={snapshot.terrain.depth}
         color={snapshot.terrain.color}
       />
-      <gridHelper
-        args={[gridSize, gridDivisions, "#2f7d37", "#5dbb63"]}
-        position={[0, 0.018, 0]}
-      />
       {snapshot.entities.map((entity) => (
         <NpcActor
           key={entity.id}
@@ -31,10 +30,20 @@ export function WorldView({ snapshot, selectedId, onSelectEntity }: WorldViewPro
         />
       ))}
       {(snapshot.resource_nodes ?? []).map((node) => (
-        <ResourceMarker key={node.id} node={node} />
+        <ResourceActor
+          key={node.id}
+          node={node}
+          isSelected={node.id === selectedId}
+          onSelect={() => onSelectEntity(node.id)}
+        />
       ))}
       {(snapshot.beasts ?? []).map((beast) => (
-        <BeastMarker key={beast.id} beast={beast} />
+        <BeastActor
+          key={beast.id}
+          beast={beast}
+          isSelected={beast.id === selectedId}
+          onSelect={() => onSelectEntity(beast.id)}
+        />
       ))}
     </group>
   );
@@ -46,67 +55,67 @@ type TerrainProps = {
   color: string;
 };
 
+const VOXEL_SIZE = 1;
+const VOXEL_HEIGHT = 0.6;
+
 function Terrain({ width, depth, color }: TerrainProps) {
-  return (
-    <mesh receiveShadow rotation={[-Math.PI / 2, 0, 0]}>
-      <planeGeometry args={[width, depth, 1, 1]} />
-      <meshStandardMaterial color={color} roughness={0.9} metalness={0.02} />
-    </mesh>
-  );
-}
+  const meshRef = useRef<InstancedMesh>(null);
+  const cols = Math.max(1, Math.round(width / VOXEL_SIZE));
+  const rows = Math.max(1, Math.round(depth / VOXEL_SIZE));
+  const count = cols * rows;
 
-function ResourceMarker({ node }: { node: ResourceNodeSnapshot }) {
-  const color = resourceColor(node.type);
-  const height = Math.max(0.12, 0.18 + node.amount * 0.035);
+  useLayoutEffect(() => {
+    const mesh = meshRef.current;
+    if (!mesh) {
+      return;
+    }
+    const base = new Color(color);
+    const dirt = new Color("#7a5a36");
+    const shade = new Color();
+    const matrix = new Matrix4();
+    let index = 0;
+    for (let col = 0; col < cols; col += 1) {
+      for (let row = 0; row < rows; row += 1) {
+        const x = (col + 0.5) * VOXEL_SIZE - width / 2;
+        const z = (row + 0.5) * VOXEL_SIZE - depth / 2;
+        const heightRoll = tileNoise(col, row, 1);
+        const tintRoll = tileNoise(col, row, 2);
+        // Subtle steps only — keep the surface readable as flat ground.
+        const lift = heightRoll > 0.94 ? 0.08 : heightRoll > 0.84 ? 0.04 : 0;
+        matrix.makeTranslation(x, lift - VOXEL_HEIGHT / 2, z);
+        mesh.setMatrixAt(index, matrix);
+        shade.copy(base);
+        shade.offsetHSL((tintRoll - 0.5) * 0.02, (heightRoll - 0.5) * 0.08, (tintRoll - 0.5) * 0.07);
+        if (tintRoll > 0.975) {
+          shade.lerp(dirt, 0.65);
+        }
+        mesh.setColorAt(index, shade);
+        index += 1;
+      }
+    }
+    mesh.instanceMatrix.needsUpdate = true;
+    if (mesh.instanceColor) {
+      mesh.instanceColor.needsUpdate = true;
+    }
+  }, [cols, rows, width, depth, color]);
 
   return (
-    <group position={[node.position.x, node.position.y, node.position.z]}>
-      <mesh castShadow receiveShadow position={[0, height / 2, 0]}>
-        <cylinderGeometry args={[0.42, 0.5, height, 12]} />
-        <meshStandardMaterial color={color} roughness={0.78} />
-      </mesh>
-      <mesh rotation={[-Math.PI / 2, 0, 0]} position={[0, 0.025, 0]}>
-        <ringGeometry args={[0.55, 0.72, 20]} />
-        <meshBasicMaterial color={color} transparent opacity={0.45} />
+    <group>
+      <instancedMesh key={count} ref={meshRef} args={[undefined, undefined, count]} receiveShadow>
+        <boxGeometry args={[VOXEL_SIZE, VOXEL_HEIGHT, VOXEL_SIZE]} />
+        <meshStandardMaterial color="#ffffff" roughness={0.9} metalness={0.02} />
+      </instancedMesh>
+      {/* dirt slab so the world edge reads as a floating voxel block */}
+      <mesh position={[0, -VOXEL_HEIGHT - 0.7, 0]}>
+        <boxGeometry args={[width, 1.6, depth]} />
+        <meshStandardMaterial color="#6b4a2c" roughness={0.95} />
       </mesh>
     </group>
   );
 }
 
-function BeastMarker({ beast }: { beast: BeastSnapshot }) {
-  const isDead = beast.state === "dead";
-  const color = isDead ? "#3d3532" : "#8f1f17";
-
-  return (
-    <group position={[beast.position.x, beast.position.y, beast.position.z]}>
-      <mesh castShadow receiveShadow position={[0, 0.65, 0]} scale={[1.15, 0.72, 1.55]}>
-        <sphereGeometry args={[0.72, 18, 14]} />
-        <meshStandardMaterial color={color} roughness={0.82} metalness={0.02} />
-      </mesh>
-      <mesh castShadow position={[0, 1.08, -0.55]} scale={[0.72, 0.62, 0.72]}>
-        <sphereGeometry args={[0.44, 16, 12]} />
-        <meshStandardMaterial color={color} roughness={0.8} />
-      </mesh>
-      <mesh rotation={[-Math.PI / 2, 0, 0]} position={[0, 0.04, 0]}>
-        <ringGeometry args={[0.85, 1.12, 28]} />
-        <meshBasicMaterial color="#ffb09c" transparent opacity={isDead ? 0.18 : 0.58} />
-      </mesh>
-    </group>
-  );
+function tileNoise(x: number, z: number, seed: number): number {
+  const value = Math.sin(x * 127.1 + z * 311.7 + seed * 74.7) * 43758.5453;
+  return value - Math.floor(value);
 }
 
-function resourceColor(type: string) {
-  if (type === "food") {
-    return "#e3c454";
-  }
-  if (type === "herbs") {
-    return "#58a65c";
-  }
-  if (type === "wood") {
-    return "#7a5234";
-  }
-  if (type === "weapon") {
-    return "#b7bec8";
-  }
-  return "#d9d2aa";
-}

src/god_simulator/simulation/actions/__init__.py

@@ -1,18 +1,19 @@
-"""Action registry and motivation-aware action masks."""
+"""Primitive action registry and motivation-aware action hints."""
 
-from god_simulator.simulation.actions.builtin import BUILTIN_ACTIONS
-from god_simulator.simulation.actions.masks import build_action_mask
+from god_simulator.simulation.actions.builtin import BUILTIN_ACTIONS, PRIMITIVE_ACTION_IDS
+from god_simulator.simulation.actions.hints import build_action_hints
 from god_simulator.simulation.actions.registry import (
     all_action_definitions,
     get_action_definition,
 )
-from god_simulator.simulation.actions.schemas import ActionDefinition, ActionMask
+from god_simulator.simulation.actions.schemas import ActionDefinition, ActionHints
 
 __all__ = [
     "BUILTIN_ACTIONS",
+    "PRIMITIVE_ACTION_IDS",
     "ActionDefinition",
-    "ActionMask",
+    "ActionHints",
     "all_action_definitions",
-    "build_action_mask",
+    "build_action_hints",
     "get_action_definition",
 ]

src/god_simulator/simulation/actions/builtin.py

@@ -2,94 +2,58 @@ from __future__ import annotations
 
 from god_simulator.simulation.actions.schemas import ActionDefinition
 
+# The whole action surface: six parameterized primitives. Behavioral flavor
+# (fleeing, pleading, threatening, stealing, healing...) is expressed through
+# parameters and free-text intent, not through dedicated action ids.
 BUILTIN_ACTIONS: dict[str, ActionDefinition] = {
-    "walk": ActionDefinition(
-        id="walk",
+    "move": ActionDefinition(
+        id="move",
         category="movement",
-        description_for_model="Move one block in routine mode.",
-        required_params=("target_x", "target_z"),
-        forbidden_modes=("threatened", "hostile_pursuit"),
+        description_for_model=(
+            "Move toward a position, NPC, beast, or resource node. "
+            "Set away=true to move away from the target instead (flee)."
+        ),
     ),
-    "talk": ActionDefinition(
-        id="talk",
+    "speak": ActionDefinition(
+        id="speak",
         category="social",
-        description_for_model="Say direct speech to a nearby citizen in routine mode.",
-        required_params=("target_npc_id", "message"),
-        forbidden_modes=("threatened", "hostile_pursuit", "fleeing"),
-    ),
-    "attack": ActionDefinition(
-        id="attack",
+        description_for_model=(
+            "Say one short message. With target_id it is direct speech; without "
+            "a target it is a shout heard by everyone nearby (e.g. a call for help)."
+        ),
+        required_params=("message",),
+    ),
+    "strike": ActionDefinition(
+        id="strike",
         category="combat",
-        description_for_model="Attack a nearby target; the engine resolves damage.",
-        required_params=("target_npc_id",),
-        allowed_modes=("hostile_pursuit",),
+        description_for_model=(
+            "Attack a nearby NPC or beast. The engine resolves movement, damage, and death."
+        ),
+        required_params=("target_id",),
+    ),
+    "use": ActionDefinition(
+        id="use",
+        category="resource",
+        description_for_model=(
+            "Use something: gather from a resource node (resource_id), eat food "
+            "(item=food), or heal with herbs (item=herbs)."
+        ),
+    ),
+    "transfer": ActionDefinition(
+        id="transfer",
+        category="resource",
+        description_for_model=(
+            "Give a resource to a nearby NPC, or set take=true to steal from them."
+        ),
+        required_params=("target_id",),
     ),
     "idle": ActionDefinition(
         id="idle",
         category="passive",
-        description_for_model="Do nothing when no safer action exists.",
-    ),
-    "flee": ActionDefinition(
-        id="flee",
-        category="survival",
-        description_for_model="Move away from the nearest threat.",
-        allowed_modes=("threatened", "fleeing"),
-    ),
-    "defend": ActionDefinition(
-        id="defend",
-        category="survival",
-        description_for_model="Hold position defensively and watch the threat.",
-        allowed_modes=("threatened", "helping"),
-    ),
-    "call_for_help": ActionDefinition(
-        id="call_for_help",
-        category="social_crisis",
-        description_for_model="Call nearby citizens for help in a crisis.",
-        allowed_modes=("threatened", "helping"),
-    ),
-    "plead": ActionDefinition(
-        id="plead",
-        category="social_crisis",
-        description_for_model="Address a threat with a short plea or de-escalation.",
-        required_params=("target_npc_id", "message"),
-        allowed_modes=("threatened",),
-    ),
-    "threaten": ActionDefinition(
-        id="threaten",
-        category="hostile_social",
-        description_for_model="Threaten the target without deciding damage or outcome.",
-        required_params=("target_npc_id", "message"),
-        allowed_modes=("hostile_pursuit",),
-    ),
-    "observe": ActionDefinition(
-        id="observe",
-        category="awareness",
-        description_for_model="Observe the current situation without routine chatter.",
-    ),
-    "investigate": ActionDefinition(
-        id="investigate",
-        category="awareness",
-        description_for_model="Move toward or observe a suspicious target or event.",
-        allowed_modes=("investigating", "routine"),
-    ),
-    "search_target": ActionDefinition(
-        id="search_target",
-        category="hostile_movement",
-        description_for_model="Search for the hostile directive target.",
-        allowed_modes=("hostile_pursuit",),
-    ),
-    "move_to_target": ActionDefinition(
-        id="move_to_target",
-        category="targeted_movement",
-        description_for_model="Move toward a specific target without resolving an outcome.",
-        required_params=("target_npc_id",),
-        allowed_modes=("hostile_pursuit", "investigating"),
-    ),
-    "attack_back": ActionDefinition(
-        id="attack_back",
-        category="combat",
-        description_for_model="Attack the threatening citizen in self-defense.",
-        required_params=("target_npc_id",),
-        allowed_modes=("threatened",),
+        description_for_model=(
+            "Do nothing this tick: wait, observe, or hold position defensively."
+        ),
     ),
 }
+
+PRIMITIVE_ACTION_IDS: tuple[str, ...] = tuple(BUILTIN_ACTIONS)

src/god_simulator/simulation/actions/hints.py

@@ -0,0 +1,113 @@
+"""Ranked action hints for the LLM prompt.
+
+Hints replace the old hard action masks: they describe what is *plausible*
+given the citizen's goal and perception, ranked best-first, but never forbid
+anything. The engine validates only physical possibility (range, existence,
+inventory); behavioral plausibility is the model's call.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, TypeAlias
+
+from god_simulator.domain import CitizenGoal, Npc, WorldState
+from god_simulator.simulation.actions.schemas import ActionHints
+from god_simulator.simulation.mechanics import ATTACK_RADIUS, distance_between, is_alive
+from god_simulator.simulation.perception import CitizenPerception
+
+if TYPE_CHECKING:
+    from god_simulator.simulation.connectors.base import ActionKind
+else:
+    ActionKind: TypeAlias = str
+
+
+def build_action_hints(
+    world: WorldState,
+    npc: Npc,
+    perception: CitizenPerception,
+    goal: CitizenGoal | None,
+) -> ActionHints:
+    if goal is None or not is_alive(npc):
+        return ActionHints(
+            suggested_actions=[],
+            reason="Dead or unavailable citizens cannot act",
+        )
+
+    match goal.goal_type:
+        case "survive" | "call_for_help":
+            suggested: list[ActionKind] = ["move", "speak", "idle"]
+            if _goal_target_in_range(world, npc, goal):
+                suggested.insert(1, "strike")
+            return ActionHints(
+                suggested_actions=suggested,
+                reason=(
+                    "A threat is nearby: moving away, calling for help, pleading, "
+                    "defending, or striking back are the most plausible responses"
+                ),
+            )
+
+        case "pursue_and_attack_target":
+            if _goal_target_in_range(world, npc, goal):
+                return ActionHints(
+                    suggested_actions=["strike", "speak"],
+                    reason="The hostile directive target is within striking range",
+                )
+            return ActionHints(
+                suggested_actions=["move", "speak"],
+                reason="The hostile directive target is out of range; closing in is most plausible",
+            )
+
+        case "retaliate":
+            if _goal_target_in_range(world, npc, goal):
+                return ActionHints(
+                    suggested_actions=["strike", "speak", "move"],
+                    reason="The recent attacker is within reach",
+                )
+            return ActionHints(
+                suggested_actions=["move", "speak"],
+                reason="The recent attacker is out of reach",
+            )
+
+        case "help_or_defend":
+            helping: list[ActionKind] = ["speak", "idle", "move"]
+            if _goal_target_in_range(world, npc, goal):
+                helping.insert(0, "strike")
+            return ActionHints(
+                suggested_actions=helping,
+                reason="Someone nearby is being harmed; helping or defending is most plausible",
+            )
+
+        case "respond_to_event" | "investigate":
+            return ActionHints(
+                suggested_actions=["move", "idle", "speak"],
+                reason="Something suspicious happened; investigating or watching is most plausible",
+            )
+
+        case "find_food":
+            return ActionHints(
+                suggested_actions=["move", "use", "speak"],
+                reason="Hunger is high; finding and consuming food is most plausible",
+            )
+
+        case "routine_life":
+            return ActionHints(
+                suggested_actions=["move", "speak", "use", "transfer", "idle"],
+                reason="Nothing urgent is happening; everyday activity is most plausible",
+            )
+
+    return ActionHints(
+        suggested_actions=["idle"],
+        reason="Unknown goal; observing is the safest default",
+    )
+
+
+def _goal_target_in_range(world: WorldState, npc: Npc, goal: CitizenGoal) -> bool:
+    if goal.target_npc_id is None:
+        return False
+    target = next(
+        (candidate for candidate in world.npcs if candidate.id == goal.target_npc_id),
+        None,
+    )
+    if target is None or not is_alive(target):
+        return False
+    return distance_between(npc, target) <= ATTACK_RADIUS

src/god_simulator/simulation/actions/masks.py

@@ -1,177 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, TypeAlias
-
-from god_simulator.domain import CitizenGoal, Npc, WorldState
-from god_simulator.simulation.actions.schemas import ActionMask
-from god_simulator.simulation.mechanics import ATTACK_RADIUS, distance_between, is_alive
-from god_simulator.simulation.perception import CitizenPerception
-
-if TYPE_CHECKING:
-    from god_simulator.simulation.connectors.base import ActionKind
-else:
-    ActionKind: TypeAlias = str
-
-
-def build_action_mask(
-    world: WorldState,
-    npc: Npc,
-    perception: CitizenPerception,
-    goal: CitizenGoal | None,
-) -> ActionMask:
-    if goal is None or not is_alive(npc):
-        return ActionMask(
-            allowed_actions=[],
-            forbidden_actions=_all_action_ids(),
-            reason="Dead or unavailable citizens cannot act",
-            fallback_action="observe",
-        )
-
-    match goal.goal_type:
-        case "survive" | "call_for_help":
-            allowed: list[ActionKind] = ["flee", "defend", "call_for_help", "plead"]
-            if _goal_target_in_range(world, npc, goal):
-                allowed.append("attack_back")
-            return ActionMask(
-                allowed_actions=allowed,
-                forbidden_actions=[
-                    "talk",
-                    "walk",
-                    "idle",
-                    "ordinary_talk",
-                    "weather_talk",
-                    "routine_walk",
-                    "work",
-                ],
-                reason="Survival goal allows only defensive crisis actions",
-                fallback_action="flee",
-            )
-
-        case "pursue_and_attack_target":
-            if _goal_target_in_range(world, npc, goal):
-                return ActionMask(
-                    allowed_actions=["attack", "threaten"],
-                    forbidden_actions=[
-                        "talk",
-                        "walk",
-                        "idle",
-                        "ordinary_talk",
-                        "weather_talk",
-                        "routine_walk",
-                        "observe",
-                    ],
-                    reason="Hostile target is in attack range",
-                    fallback_action="attack",
-                )
-            return ActionMask(
-                allowed_actions=["move_to_target", "search_target", "threaten"],
-                forbidden_actions=[
-                    "talk",
-                    "walk",
-                    "idle",
-                    "ordinary_talk",
-                    "weather_talk",
-                    "routine_walk",
-                    "observe",
-                ],
-                reason="Hostile target is outside attack range",
-                fallback_action="move_to_target",
-            )
-
-        case "retaliate":
-            allowed = ["threaten"]
-            fallback_action: ActionKind = "move_to_target"
-            if _goal_target_in_range(world, npc, goal):
-                allowed = ["attack_back", "threaten"]
-                fallback_action = "attack_back"
-            else:
-                allowed = ["move_to_target", "threaten"]
-            return ActionMask(
-                allowed_actions=allowed,
-                forbidden_actions=["talk", "walk", "idle", "ordinary_talk", "weather_talk"],
-                reason="Recent attacker is the priority target",
-                fallback_action=fallback_action,
-            )
-
-        case "help_or_defend":
-            allowed = ["defend", "call_for_help", "plead"]
-            if _goal_target_in_range(world, npc, goal):
-                allowed.append("attack_back")
-            return ActionMask(
-                allowed_actions=allowed,
-                forbidden_actions=["talk", "walk", "idle", "ordinary_talk", "weather_talk"],
-                reason="Nearby harm calls for defense or help",
-                fallback_action="call_for_help",
-            )
-
-        case "respond_to_event" | "investigate":
-            allowed = ["investigate", "observe", "call_for_help"]
-            if perception.under_threat:
-                allowed.append("flee")
-            return ActionMask(
-                allowed_actions=allowed,
-                forbidden_actions=["talk", "ordinary_talk", "weather_talk", "routine_walk"],
-                reason="Suspicious event should be investigated or watched",
-                fallback_action="investigate",
-            )
-
-        case "find_food":
-            return ActionMask(
-                allowed_actions=["walk", "observe", "investigate"],
-                forbidden_actions=["attack", "threaten", "ordinary_talk", "weather_talk"],
-                reason="Food need is high but no economy exists yet",
-                fallback_action="observe",
-            )
-
-        case "routine_life":
-            return ActionMask(
-                allowed_actions=["walk", "talk", "observe"],
-                forbidden_actions=[
-                    "attack",
-                    "attack_back",
-                    "threaten",
-                    "flee",
-                    "call_for_help",
-                    "plead",
-                ],
-                reason="No urgent threat or hostile directive is present",
-                fallback_action="observe",
-            )
-
-    return ActionMask(
-        allowed_actions=["observe"],
-        forbidden_actions=["ordinary_talk", "weather_talk"],
-        reason="Unknown goal falls back to observation",
-        fallback_action="observe",
-    )
-
-
-def _goal_target_in_range(world: WorldState, npc: Npc, goal: CitizenGoal) -> bool:
-    if goal.target_npc_id is None:
-        return False
-    target = next(
-        (candidate for candidate in world.npcs if candidate.id == goal.target_npc_id),
-        None,
-    )
-    if target is None or not is_alive(target):
-        return False
-    return distance_between(npc, target) <= ATTACK_RADIUS
-
-
-def _all_action_ids() -> list[str]:
-    return [
-        "walk",
-        "talk",
-        "attack",
-        "idle",
-        "flee",
-        "defend",
-        "call_for_help",
-        "plead",
-        "threaten",
-        "observe",
-        "investigate",
-        "search_target",
-        "move_to_target",
-        "attack_back",
-    ]

src/god_simulator/simulation/actions/schemas.py

@@ -3,8 +3,6 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, TypeAlias
 
-from god_simulator.domain import CitizenMode
-
 if TYPE_CHECKING:
     from god_simulator.simulation.connectors.base import ActionKind
 else:
@@ -17,16 +15,16 @@ class ActionDefinition:
     category: str
     description_for_model: str
     required_params: tuple[str, ...] = ()
-    allowed_modes: tuple[CitizenMode, ...] = ()
-    forbidden_modes: tuple[CitizenMode, ...] = ()
-    preconditions: tuple[str, ...] = ()
-    fallback_policy: str = "safe_goal_fallback"
 
 
 @dataclass(frozen=True, slots=True)
-class ActionMask:
-    allowed_actions: list[ActionKind]
-    forbidden_actions: list[str]
+class ActionHints:
+    """Ranked behavioral suggestions for the LLM prompt.
+
+    Hints never forbid anything: any primitive remains choosable and the engine
+    only rejects or repairs physically impossible actions.
+    """
+
+    suggested_actions: list[ActionKind]
     reason: str
-    fallback_action: ActionKind = "observe"
     metadata: dict[str, str] = field(default_factory=dict)

src/god_simulator/simulation/autopilot.py

@@ -0,0 +1,179 @@
+"""Deterministic autopilot for social (non-survival) worlds.
+
+The autopilot fills gaps: it produces one safe, goal-consistent primitive when
+an NPC has no usable directive (LLM error, unknown action, omitted NPC). It is
+a fallback, never a filter — it does not constrain what a planner may choose.
+"""
+
+from __future__ import annotations
+
+from god_simulator.domain import CitizenGoal, Npc, WorldState
+from god_simulator.simulation.connectors.base import NpcDirective
+from god_simulator.simulation.mechanics import (
+    ATTACK_RADIUS,
+    distance_between,
+    is_alive,
+    walk_away_target,
+)
+from god_simulator.simulation.perception import CitizenPerception, nearby_threat_npc
+
+
+def autopilot_directive(
+    world: WorldState,
+    npc: Npc,
+    directive: NpcDirective,
+    perception: CitizenPerception,
+    goal: CitizenGoal | None,
+) -> NpcDirective:
+    target = target_from_directive_or_goal(world, npc, directive, goal, perception)
+
+    if (
+        goal is not None
+        and goal.goal_type in ("pursue_and_attack_target", "retaliate")
+        and target is not None
+    ):
+        return strike_or_approach_target(
+            npc,
+            directive,
+            target,
+            memory="Autopilot pursued the hostile target.",
+        )
+
+    if goal is not None and goal.goal_type in ("survive", "call_for_help", "help_or_defend"):
+        if goal.goal_type == "call_for_help":
+            return NpcDirective(
+                npc_id=npc.id,
+                action="speak",
+                message="Help! I am in danger!",
+                memory="Autopilot called for help.",
+                communication_intent="help_request",
+                intent="call_for_help",
+            )
+        if target is not None:
+            return flee_directive(world, npc, target, directive)
+        return idle_directive(
+            directive,
+            memory="Autopilot held a defensive stance.",
+            intent="defend",
+        )
+
+    if (
+        goal is not None
+        and goal.goal_type in ("respond_to_event", "investigate")
+        and target is not None
+    ):
+        return move_toward_target_directive(npc, directive, target, intent="investigate")
+
+    return idle_directive(directive, memory=None, intent="observe")
+
+
+def target_from_directive_or_goal(
+    world: WorldState,
+    npc: Npc,
+    directive: NpcDirective,
+    goal: CitizenGoal | None,
+    perception: CitizenPerception,
+) -> Npc | None:
+    if directive.target_npc_id:
+        target = _npc_by_id(world, directive.target_npc_id)
+        if target is not None and target.id != npc.id and is_alive(target):
+            return target
+
+    if goal is not None and goal.target_npc_id:
+        target = _npc_by_id(world, goal.target_npc_id)
+        if target is not None and target.id != npc.id and is_alive(target):
+            return target
+
+    threat = nearby_threat_npc(world, perception)
+    if threat is not None and threat.id != npc.id and is_alive(threat):
+        return threat
+
+    return None
+
+
+def strike_or_approach_target(
+    npc: Npc,
+    directive: NpcDirective,
+    target: Npc,
+    *,
+    memory: str,
+) -> NpcDirective:
+    if distance_between(npc, target) <= ATTACK_RADIUS:
+        return NpcDirective(
+            npc_id=npc.id,
+            action="strike",
+            target_npc_id=target.id,
+            message=directive.message,
+            memory=memory,
+            intent="hostile_attack",
+            confidence=directive.confidence,
+        )
+    return move_toward_target_directive(
+        npc,
+        directive,
+        target,
+        intent="approach_target_for_attack",
+        memory=memory,
+    )
+
+
+def move_toward_target_directive(
+    npc: Npc,
+    directive: NpcDirective,
+    target: Npc,
+    *,
+    intent: str,
+    memory: str | None = None,
+) -> NpcDirective:
+    return NpcDirective(
+        npc_id=npc.id,
+        action="move",
+        target=target.position,
+        target_npc_id=target.id,
+        message=directive.message,
+        memory=memory or f"You moved toward {target.name}.",
+        intent=intent,
+        confidence=directive.confidence,
+    )
+
+
+def flee_directive(
+    world: WorldState,
+    npc: Npc,
+    threat: Npc,
+    directive: NpcDirective,
+) -> NpcDirective:
+    half_width = world.terrain.width / 2
+    half_depth = world.terrain.depth / 2
+    return NpcDirective(
+        npc_id=npc.id,
+        action="move",
+        target=walk_away_target(npc, threat, half_width=half_width, half_depth=half_depth),
+        target_npc_id=threat.id,
+        message=directive.message,
+        memory=f"You backed away from {threat.name}.",
+        intent="flee_from_threat",
+        confidence=directive.confidence,
+    )
+
+
+def idle_directive(
+    directive: NpcDirective,
+    *,
+    memory: str | None,
+    intent: str,
+) -> NpcDirective:
+    return NpcDirective(
+        npc_id=directive.npc_id,
+        action="idle",
+        target=None,
+        target_npc_id=directive.target_npc_id,
+        message=directive.message,
+        memory=memory,
+        intent=intent,
+        confidence=directive.confidence,
+    )
+
+
+def _npc_by_id(world: WorldState, npc_id: str) -> Npc | None:
+    return next((candidate for candidate in world.npcs if candidate.id == npc_id), None)

src/god_simulator/simulation/connectors/base.py

@@ -5,35 +5,10 @@ from typing import Literal, Protocol, TypeAlias
 
 from god_simulator.domain import Vec3, WorldState
 
-EngineActionKind: TypeAlias = Literal["walk", "talk", "attack", "idle"]
-SemanticActionKind: TypeAlias = Literal[
-    "flee",
-    "defend",
-    "call_for_help",
-    "plead",
-    "threaten",
-    "observe",
-    "investigate",
-    "search_target",
-    "move_to_target",
-    "attack_back",
-]
-SurvivalActionKind: TypeAlias = Literal[
-    "gather",
-    "consume",
-    "eat",
-    "heal",
-    "move_to_resource",
-    "move_to",
-    "communicate",
-    "transfer",
-    "trade",
-    "request_trade",
-    "steal",
-    "find_food",
-    "find_herbs",
-]
-ActionKind: TypeAlias = EngineActionKind | SemanticActionKind | SurvivalActionKind
+# The public action surface: every NPC decision is one of these six primitives.
+# Legacy action names (walk, talk, attack, gather, flee, ...) are accepted as raw
+# strings at parse/validation boundaries and normalized to primitives there.
+ActionKind: TypeAlias = Literal["move", "speak", "strike", "use", "transfer", "idle"]
 
 
 @dataclass(frozen=True, slots=True)
@@ -50,6 +25,8 @@ class CitizenAction:
     message: str | None = None
     intent: str | None = None
     confidence: float | None = None
+    away: bool = False
+    take: bool = False
 
 
 @dataclass(frozen=True, slots=True)
@@ -67,6 +44,8 @@ class NpcDirective:
     memory: str | None = None
     intent: str | None = None
     confidence: float | None = None
+    away: bool = False
+    take: bool = False
     conversation_user: str | None = None
     conversation_assistant: str | None = None
 
@@ -74,7 +53,9 @@ class NpcDirective:
 @dataclass(frozen=True, slots=True)
 class ValidationResult:
     valid: bool
-    original_action: ActionKind
+    # The original action is whatever the planner/LLM asked for, including
+    # legacy aliases or unknown ids; the resolved action is always a primitive.
+    original_action: str
     resolved_action: ActionKind
     reason: str
     directive: NpcDirective

src/god_simulator/simulation/connectors/deterministic.py

@@ -36,7 +36,7 @@ class DeterministicWorldSimulator:
             directives.append(
                 NpcDirective(
                     npc_id=npc.id,
-                    action="walk",
+                    action="move",
                     target=target,
                 )
             )

src/god_simulator/simulation/connectors/openai_compatible.py

@@ -4,14 +4,15 @@ import json
 import os
 from collections.abc import Callable, Sequence
 from concurrent.futures import ThreadPoolExecutor
-from dataclasses import asdict
+from dataclasses import asdict, replace
 from typing import Any, cast
 
 from openai import OpenAI
 
 from god_simulator.config import ConnectorConfig
 from god_simulator.domain import Npc, Vec3, WorldState
-from god_simulator.simulation.actions import ActionMask, build_action_mask
+from god_simulator.simulation.actions import ActionHints, build_action_hints
+from god_simulator.simulation.autopilot import autopilot_directive
 from god_simulator.simulation.connectors.base import (
     ActionKind,
     NpcDirective,
@@ -26,226 +27,176 @@ from god_simulator.simulation.mechanics import (
     MAX_WALK_DISTANCE,
     TALK_RADIUS,
     VISIBLE_RADIUS,
-    distance_between,
-    has_hostile_intent,
     is_alive,
-    vec_distance,
 )
 from god_simulator.simulation.memory import recent_meaningful_memories
 from god_simulator.simulation.perception import CitizenPerception
 from god_simulator.simulation.survival import (
-    GOAL_ACTIONS,
+    GOAL_SUGGESTED_ACTIONS,
     build_memory_summary,
     build_perception,
     build_relationships_summary,
     is_survival_world,
-    nearest_beast,
     survival_directive_for,
 )
 from god_simulator.simulation.survival import select_goal as select_survival_goal
 
 ChatCompleter = Callable[[dict[str, Any]], dict[str, Any]]
 
-LEGACY_ACTION_TOOLS = {
-    "walk",
-    "talk",
-    "attack",
-    "call_for_help",
-    "eat",
-    "trade",
-    "request_trade",
-}
-
+# One tool per primitive. Every NPC always sees all six; suggested_actions in
+# the payload are ranked hints, never restrictions.
 TOOL_DEFINITIONS: dict[str, dict[str, Any]] = {
-    "flee": {
+    "move": {
         "type": "function",
         "function": {
-            "name": "flee",
-            "description": "Run away from the nearest threat at full speed.",
+            "name": "move",
+            "description": (
+                "Move toward a position, NPC, beast, or resource node. "
+                "Set away=true to move away from the target instead (flee)."
+            ),
             "parameters": {
                 "type": "object",
                 "properties": {
-                    "threat_id": {
+                    "target_id": {
                         "type": "string",
-                        "description": "Optional visible beast id.",
-                    }
+                        "description": "Optional visible NPC, beast, or resource node id.",
+                    },
+                    "target_x": {
+                        "type": "number",
+                        "description": "Optional desired x coordinate.",
+                    },
+                    "target_z": {
+                        "type": "number",
+                        "description": "Optional desired z coordinate.",
+                    },
+                    "away": {
+                        "type": "boolean",
+                        "description": "Move away from the target/threat instead of toward it.",
+                    },
                 },
                 "required": [],
                 "additionalProperties": False,
             },
         },
     },
-    "communicate": {
+    "speak": {
         "type": "function",
         "function": {
-            "name": "communicate",
-            "description": "Say one short message for help, warning, trade, or social contact.",
+            "name": "speak",
+            "description": (
+                "Say one short message. With target_id it is direct speech; without a "
+                "target it is a shout heard by everyone nearby (e.g. a call for help)."
+            ),
             "parameters": {
                 "type": "object",
                 "properties": {
-                    "intent": {
-                        "type": "string",
-                        "enum": ["help_request", "warning", "trade_request", "social"],
-                    },
                     "target_id": {
                         "type": "string",
-                        "description": "Optional nearby NPC id.",
+                        "description": "Optional nearby NPC id to address directly.",
                     },
                     "message": {
                         "type": "string",
-                        "description": "Short direct speech.",
+                        "description": "The exact words said aloud.",
                     },
-                },
-                "required": ["intent"],
-                "additionalProperties": False,
-            },
-        },
-    },
-    "defend": {
-        "type": "function",
-        "function": {
-            "name": "defend",
-            "description": "Hold position defensively and watch the threat.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "target_id": {
+                    "intent": {
                         "type": "string",
-                        "description": "Optional NPC or beast id being defended.",
-                    }
+                        "description": (
+                            "Why you are speaking, e.g. help_request, warning, "
+                            "trade_request, social, plead, threaten."
+                        ),
+                    },
                 },
-                "required": [],
+                "required": ["message"],
                 "additionalProperties": False,
             },
         },
     },
-    "attack": {
+    "strike": {
         "type": "function",
         "function": {
-            "name": "attack",
-            "description": "Attack the nearest beast; the engine resolves movement and damage.",
+            "name": "strike",
+            "description": (
+                "Attack a nearby NPC or beast. The engine resolves movement, damage, and death."
+            ),
             "parameters": {
                 "type": "object",
                 "properties": {
                     "target_id": {
                         "type": "string",
-                        "description": "Optional beast id.",
+                        "description": "Visible NPC or beast id to attack.",
                     }
                 },
-                "required": [],
-                "additionalProperties": False,
-            },
-        },
-    },
-    "heal": {
-        "type": "function",
-        "function": {
-            "name": "heal",
-            "description": "Use one herb to heal yourself.",
-            "parameters": {
-                "type": "object",
-                "properties": {},
-                "required": [],
+                "required": ["target_id"],
                 "additionalProperties": False,
             },
         },
     },
-    "consume": {
+    "use": {
         "type": "function",
         "function": {
-            "name": "consume",
-            "description": "Eat one food from inventory.",
-            "parameters": {
-                "type": "object",
-                "properties": {},
-                "required": [],
-                "additionalProperties": False,
-            },
-        },
-    },
-    "gather": {
-        "type": "function",
-        "function": {
-            "name": "gather",
-            "description": "Collect resource from a nearby node.",
+            "name": "use",
+            "description": (
+                "Use something: gather from a resource node (resource_id), eat food "
+                "(item=food), or heal with herbs (item=herbs)."
+            ),
             "parameters": {
                 "type": "object",
                 "properties": {
                     "resource_id": {
                         "type": "string",
-                        "description": "ID of the resource node to gather from.",
-                    }
-                },
-                "required": ["resource_id"],
-                "additionalProperties": False,
-            },
-        },
-    },
-    "move_to_resource": {
-        "type": "function",
-        "function": {
-            "name": "move_to_resource",
-            "description": "Move toward the most relevant known resource node.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "resource_id": {
+                        "description": "Nearby resource node id to gather from.",
+                    },
+                    "item": {
                         "type": "string",
-                        "description": "Optional ID of the resource node to approach.",
-                    }
+                        "enum": ["food", "herbs"],
+                        "description": "Inventory item to consume.",
+                    },
                 },
                 "required": [],
                 "additionalProperties": False,
             },
         },
     },
-    "move_to": {
-        "type": "function",
-        "function": {
-            "name": "move_to",
-            "description": "Wander or reposition when no urgent action is needed.",
-            "parameters": {
-                "type": "object",
-                "properties": {},
-                "required": [],
-                "additionalProperties": False,
-            },
-        },
-    },
     "transfer": {
         "type": "function",
         "function": {
             "name": "transfer",
-            "description": "Give one of your resources to a nearby NPC.",
+            "description": (
+                "Give a resource to a nearby NPC, or set take=true to steal from them."
+            ),
             "parameters": {
                 "type": "object",
                 "properties": {
                     "target_id": {
                         "type": "string",
-                        "description": "Nearby NPC id to receive the resource.",
+                        "description": "Nearby NPC id.",
                     },
                     "resource_type": {
                         "type": "string",
                         "enum": ["food", "herbs", "wood", "weapon"],
                     },
                     "amount": {"type": "integer", "minimum": 1, "maximum": 5},
+                    "take": {
+                        "type": "boolean",
+                        "description": "Steal from the target instead of giving.",
+                    },
                 },
-                "required": ["target_id", "resource_type"],
+                "required": ["target_id"],
                 "additionalProperties": False,
             },
         },
     },
-    "steal": {
+    "idle": {
         "type": "function",
         "function": {
-            "name": "steal",
-            "description": "Steal food from a nearby NPC as a desperate hostile act.",
+            "name": "idle",
+            "description": "Do nothing this tick: wait, observe, or hold position defensively.",
             "parameters": {
                 "type": "object",
                 "properties": {
-                    "target_id": {
+                    "intent": {
                         "type": "string",
-                        "description": "Optional nearby NPC id to steal from.",
+                        "description": "Optional flavor, e.g. observe or defend.",
                     }
                 },
                 "required": [],
@@ -253,87 +204,11 @@ TOOL_DEFINITIONS: dict[str, dict[str, Any]] = {
             },
         },
     },
-    "talk": {
-        "type": "function",
-        "function": {
-            "name": "talk",
-            "description": "Say a short direct line to a nearby NPC.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "target_npc_id": {"type": "string"},
-                    "message": {"type": "string"},
-                },
-                "required": ["target_npc_id", "message"],
-                "additionalProperties": False,
-            },
-        },
-    },
 }
 
 
-def build_tool_list_for_goal(goal: str) -> list[dict[str, Any]]:
-    allowed = GOAL_ACTIONS.get(goal, [])
-    return [TOOL_DEFINITIONS[action] for action in allowed[:7] if action in TOOL_DEFINITIONS]
-
-
-def _action_tools(allowed_actions: Sequence[ActionKind]) -> list[dict[str, Any]]:
-    enum_actions = list(allowed_actions) or ["observe"]
-    return [
-        {
-            "type": "function",
-            "function": {
-                "name": "choose_action",
-                "description": (
-                    "Choose exactly one allowed action for this NPC. The engine validates "
-                    "movement, damage, death, and side effects."
-                ),
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "npc_id": {
-                            "type": "string",
-                            "description": "Existing living NPC id, such as npc-001.",
-                        },
-                        "action": {
-                            "type": "string",
-                            "enum": enum_actions,
-                            "description": "One action id from allowed_actions.",
-                        },
-                        "target_npc_id": {
-                            "type": "string",
-                            "description": (
-                                "Known visible NPC id when the action targets a citizen."
-                            ),
-                        },
-                        "target_x": {
-                            "type": "number",
-                            "description": "Optional desired x coordinate for movement actions.",
-                        },
-                        "target_z": {
-                            "type": "number",
-                            "description": "Optional desired z coordinate for movement actions.",
-                        },
-                        "message": {
-                            "type": "string",
-                            "description": "Direct speech only for talk, plead, threaten, or help.",
-                        },
-                        "intent": {
-                            "type": "string",
-                            "description": "Short reason for choosing this action.",
-                        },
-                        "confidence": {
-                            "type": "number",
-                            "minimum": 0,
-                            "maximum": 1,
-                        },
-                    },
-                    "required": ["npc_id", "action"],
-                    "additionalProperties": False,
-                },
-            },
-        }
-    ]
+def primitive_tools() -> list[dict[str, Any]]:
+    return list(TOOL_DEFINITIONS.values())
 
 
 class OpenAICompatibleWorldSimulator:
@@ -502,16 +377,13 @@ class OpenAICompatibleWorldSimulator:
 
         if is_survival_world(world):
             survival_goal = select_survival_goal(npc, world)
-            allowed = GOAL_ACTIONS.get(survival_goal) or ["observe"]
-            messages = _build_survival_messages(world, next_tick, npc, survival_goal, allowed)
-            tools = build_tool_list_for_goal(survival_goal)
-            if not tools:
-                tools = _action_tools(cast(list[ActionKind], allowed))
+            suggested = GOAL_SUGGESTED_ACTIONS.get(survival_goal) or ["idle"]
+            messages = _build_survival_messages(world, next_tick, npc, survival_goal, suggested)
         else:
             perception, goal = refresh_citizen_motivation(world, npc)
-            action_mask = build_action_mask(world, npc, perception, goal)
-            messages = _build_messages(world, next_tick, npc, perception, action_mask)
-            tools = _action_tools(action_mask.allowed_actions)
+            hints = build_action_hints(world, npc, perception, goal)
+            messages = _build_messages(world, next_tick, npc, perception, hints)
+        tools = primitive_tools()
 
         request: dict[str, Any] = {
             "model": self._config.model,
@@ -540,7 +412,7 @@ def _build_messages(
     next_tick: int,
     npc: Npc,
     perception: CitizenPerception,
-    action_mask: ActionMask,
+    hints: ActionHints,
 ) -> list[dict[str, str]]:
     half_width = world.terrain.width / 2
     half_depth = world.terrain.depth / 2
@@ -551,9 +423,10 @@ def _build_messages(
             "content": (
                 f"You are {npc.name}, a {npc.role} in a small civilization sandbox. "
                 "Choose only your own next action from your current state and observations. "
-                "Use exactly one choose_action tool call. Do not write prose, "
-                "JSON, narration, or reasoning text. For talk, the message argument is "
-                "the exact words you say aloud. Choose only from allowed_actions."
+                "Call exactly one tool. Do not write prose, JSON, narration, or "
+                "reasoning text. For speak, the message argument is the exact words "
+                "you say aloud. suggested_actions are ranked hints, not restrictions: "
+                "any tool is allowed and the engine repairs physically impossible actions."
             ),
         },
         {
@@ -576,9 +449,9 @@ def _build_messages(
                         f"one block is {BLOCK_SIZE:g} world coordinate units",
                         "prefer target coordinates at block centers",
                         "do not invent npc ids",
-                        f"walk moves at most {MAX_WALK_DISTANCE:g} world units per tick",
-                        f"talk requires target distance <= {TALK_RADIUS:g} world units",
-                        f"attack requires target distance <= {ATTACK_RADIUS:g} world units",
+                        f"move covers at most {MAX_WALK_DISTANCE:g} world units per tick",
+                        f"speak requires target distance <= {TALK_RADIUS:g} world units",
+                        f"strike requires target distance <= {ATTACK_RADIUS:g} world units",
                         f"each NPC can see only visible_npcs within {VISIBLE_RADIUS:g} world units",
                         "visible_npcs is the full set of other NPCs you can currently observe",
                         "do not target dead NPCs",
@@ -592,14 +465,9 @@ def _build_messages(
                             "you choose only the attempted action; "
                             "the engine resolves damage and death"
                         ),
-                        "choose exactly one action from allowed_actions",
-                        "never choose an action from forbidden_actions",
-                        "ordinary weather or generic small talk is forbidden during crisis",
-                        "do not choose ordinary small talk during threatened or hostile modes",
-                        "if threatened, prefer fleeing, pleading, help, defense, or attacking back",
                         (
-                            "if you want to attack a far target, walk toward them "
-                            "or let the engine convert it"
+                            "out-of-range speak or strike is automatically converted "
+                            "into movement toward the target"
                         ),
                     ],
                     "world": {
@@ -613,15 +481,14 @@ def _build_messages(
                             "block_size": BLOCK_SIZE,
                         },
                     },
-                    "npc": _npc_context(world, npc, perception, action_mask),
+                    "npc": _npc_context(world, npc, perception, hints),
                     "needs": asdict(npc.needs),
                     "emotions": asdict(npc.emotions),
                     "current_goal": asdict(npc.current_goal) if npc.current_goal else None,
                     "current_mode": npc.mode,
                     "perception": perception.to_dict(),
-                    "allowed_actions": action_mask.allowed_actions,
-                    "forbidden_actions": action_mask.forbidden_actions,
-                    "action_mask_reason": action_mask.reason,
+                    "suggested_actions": hints.suggested_actions,
+                    "suggestion_reason": hints.reason,
                 },
                 ensure_ascii=False,
             ),
@@ -634,7 +501,7 @@ def _build_survival_messages(
     next_tick: int,
     npc: Npc,
     goal: str,
-    allowed_actions: Sequence[str],
+    suggested_actions: Sequence[str],
 ) -> list[dict[str, str]]:
     """Build a compact single-NPC survival prompt."""
     _ = next_tick
@@ -659,7 +526,7 @@ def _build_survival_messages(
             "weapon": npc.inventory_weapon,
         },
         "goal": goal,
-        "allowed_actions": list(allowed_actions),
+        "suggested_actions": list(suggested_actions),
         "perception": build_perception(npc, world),
         "memory": build_memory_summary(npc, last_n=3, current_tick=world.tick),
         "relationships": build_relationships_summary(npc, world),
@@ -669,8 +536,9 @@ def _build_survival_messages(
         {
             "role": "system",
             "content": (
-                f"You are {npc.name}. Choose exactly one allowed tool/action for the next tick. "
-                "Do not invent ids. Do not mutate world state; the engine validates and applies effects."
+                f"You are {npc.name}. Call exactly one tool for the next tick. "
+                "suggested_actions are ranked hints, not restrictions. Do not invent ids. "
+                "Do not mutate world state; the engine validates and applies effects."
             ),
         },
         *npc.conversation_context.messages,
@@ -685,11 +553,11 @@ def _npc_context(
     world: WorldState,
     npc: Npc,
     perception: CitizenPerception | None = None,
-    action_mask: ActionMask | None = None,
+    hints: ActionHints | None = None,
 ) -> dict[str, Any]:
-    if perception is None or action_mask is None:
+    if perception is None or hints is None:
         perception, goal = refresh_citizen_motivation(world, npc)
-        action_mask = build_action_mask(world, npc, perception, goal)
+        hints = build_action_hints(world, npc, perception, goal)
 
     return {
         "id": npc.id,
@@ -705,8 +573,7 @@ def _npc_context(
         "current_goal": asdict(npc.current_goal) if npc.current_goal else None,
         "needs": asdict(npc.needs),
         "emotions": asdict(npc.emotions),
-        "allowed_actions": action_mask.allowed_actions,
-        "forbidden_actions": action_mask.forbidden_actions,
+        "suggested_actions": hints.suggested_actions,
         "memory_summary": npc.memory_summary,
         "recent_observations": [
             {
@@ -719,11 +586,10 @@ def _npc_context(
         "nearby_threats": perception.nearby_threats,
         "under_threat": perception.under_threat,
         "threat_response_options": [
-            "flee",
-            "defend",
-            "call_for_help",
-            "plead",
-            "attack_back if the threat is within attack range",
+            "move away from the threat",
+            "speak to plead or call for help",
+            "idle defensively",
+            "strike back if the threat is within attack range",
         ]
         if perception.nearby_threats
         else [],
@@ -778,27 +644,19 @@ def _parse_tool_calls(
         if not isinstance(function, dict):
             continue
         tool_name = function.get("name")
-        if (
-            tool_name != "choose_action"
-            and tool_name not in LEGACY_ACTION_TOOLS
-            and tool_name not in TOOL_DEFINITIONS
-        ):
+        if tool_name not in TOOL_DEFINITIONS:
             continue
         try:
             arguments = _parse_arguments(function.get("arguments"))
         except json.JSONDecodeError as exc:
             print(f"Ignoring malformed LLM tool call arguments: {exc}", flush=True)
             continue
-        if arguments is None and (tool_name in TOOL_DEFINITIONS or tool_name in LEGACY_ACTION_TOOLS):
+        if arguments is None:
             arguments = {}
-        if arguments is not None:
-            if tool_name in LEGACY_ACTION_TOOLS:
-                arguments["action"] = tool_name
-            elif tool_name != "choose_action":
-                arguments["action"] = tool_name
-            if npc_id is not None and "npc_id" not in arguments:
-                arguments["npc_id"] = npc_id
-            actions.append(arguments)
+        arguments["action"] = tool_name
+        if npc_id is not None and "npc_id" not in arguments:
+            arguments["npc_id"] = npc_id
+        actions.append(arguments)
 
     return _actions_to_plan(actions, world, source=source)
 
@@ -835,10 +693,10 @@ def _parse_text_content(
         return TickPlan(source=source, directives=[])
 
     payload: dict[str, Any] = {"npc_id": resolved_npc_id, "action": action}
-    if len(tokens) > 1 and action in {"gather", "move_to_resource"}:
+    if len(tokens) > 1 and action in {"use", "move"}:
         payload["resource_id"] = tokens[1]
-    if len(tokens) > 1 and action in {"trade", "request_trade", "steal", "talk"}:
-        payload["target_npc_id"] = tokens[1]
+    if len(tokens) > 1 and action in {"transfer", "speak", "strike"}:
+        payload["target_id"] = tokens[1]
     return _actions_to_plan([payload], world, source=source)
 
 
@@ -863,14 +721,22 @@ def _actions_to_plan(actions: Sequence[object], world: WorldState, *, source: st
         target = _target_from_action(action, half_width=half_width, half_depth=half_depth)
         raw_target_id = action.get("target_id") or action.get("target_npc_id")
         target_npc_id = _optional_known_npc_id(raw_target_id, world)
-        target_entity_id = None if target_npc_id else _optional_known_entity_id(raw_target_id, world)
+        target_entity_id = (
+            None if target_npc_id else _optional_known_entity_id(raw_target_id, world)
+        )
         resource_id = _optional_resource_id(action.get("resource_id"), world)
-        resource_type = _optional_resource_type(action.get("resource_type"))
+        if resource_id is None and target_npc_id is None and target_entity_id is None:
+            resource_id = _optional_resource_id(raw_target_id, world)
+        resource_type = _optional_resource_type(
+            action.get("resource_type") or action.get("item")
+        )
         amount = _optional_amount(action.get("amount"))
         communication_intent = _optional_communication_intent(action.get("intent"))
         message = _optional_short_text(action.get("message"), limit=140)
         intent = _optional_short_text(action.get("intent"), limit=80)
         confidence = _optional_confidence(action.get("confidence"))
+        away = action.get("away") is True
+        take = action.get("take") is True
 
         directives.append(
             NpcDirective(
@@ -886,6 +752,8 @@ def _actions_to_plan(actions: Sequence[object], world: WorldState, *, source: st
                 message=message,
                 intent=intent,
                 confidence=confidence,
+                away=away,
+                take=take,
             )
         )
 
@@ -893,37 +761,8 @@ def _actions_to_plan(actions: Sequence[object], world: WorldState, *, source: st
 
 
 def _action_kind(raw: object) -> ActionKind | None:
-    if raw in (
-        "walk",
-        "talk",
-        "attack",
-        "idle",
-        "flee",
-        "defend",
-        "call_for_help",
-        "plead",
-        "threaten",
-        "observe",
-        "investigate",
-        "search_target",
-        "move_to_target",
-        "attack_back",
-        # Survival actions (resolved by the survival engine in survival worlds).
-        "gather",
-        "consume",
-        "eat",
-        "heal",
-        "move_to_resource",
-        "move_to",
-        "communicate",
-        "transfer",
-        "trade",
-        "request_trade",
-        "steal",
-        "find_food",
-        "find_herbs",
-    ):
-        return cast(ActionKind, raw)
+    if raw in ("move", "speak", "strike", "use", "transfer", "idle"):
+        return raw
     return None
 
 
@@ -954,7 +793,7 @@ def _optional_resource_id(raw: object, world: WorldState) -> str | None:
 
 def _optional_resource_type(raw: object) -> str | None:
     if raw in {"food", "herbs", "wood", "weapon"}:
-        return cast(str, raw)
+        return raw
     return None
 
 
@@ -965,8 +804,8 @@ def _optional_amount(raw: object) -> int | None:
 
 
 def _optional_communication_intent(raw: object) -> str | None:
-    if raw in {"help_request", "warning", "trade_request", "social"}:
-        return cast(str, raw)
+    if raw in {"help_request", "warning", "trade_request", "social", "plead", "threaten"}:
+        return raw
     return None
 
 
@@ -1067,26 +906,21 @@ def _safe_fallback_directive(
     *,
     reason: str,
 ) -> NpcDirective:
+    """Deterministic autopilot directive used when the LLM output is unusable."""
     if is_survival_world(world):
         return survival_directive_for(world, npc, next_tick)
 
     perception, goal = refresh_citizen_motivation(world, npc)
-    action_mask = build_action_mask(world, npc, perception, goal)
-    action = action_mask.fallback_action
-    target_npc_id = goal.target_npc_id if goal and goal.target_npc_id else None
-
-    if target_npc_id is None and perception.nearby_threats:
-        target_npc_id = str(perception.nearby_threats[0]["npc_id"])
-    if target_npc_id is None and perception.visible_targets:
-        target_npc_id = str(perception.visible_targets[0]["npc_id"])
-
-    return NpcDirective(
-        npc_id=npc.id,
-        action=action,
-        target_npc_id=target_npc_id,
-        message=_fallback_message(action, npc),
-        memory=f"Safe fallback selected because {reason}.",
-        intent="safe_goal_fallback",
+    directive = autopilot_directive(
+        world,
+        npc,
+        NpcDirective(npc_id=npc.id),
+        perception,
+        goal,
+    )
+    return replace(
+        directive,
+        memory=directive.memory or f"Autopilot selected because {reason}.",
         confidence=0.0,
     )
 
@@ -1124,100 +958,13 @@ def _with_conversation_turn(
     user_content: str,
     assistant_content: str,
 ) -> NpcDirective:
-    return NpcDirective(
-        npc_id=directive.npc_id,
-        action=directive.action,
-        target=directive.target,
-        target_npc_id=directive.target_npc_id,
-        target_entity_id=directive.target_entity_id,
-        resource_id=directive.resource_id,
-        resource_type=directive.resource_type,
-        amount=directive.amount,
-        communication_intent=directive.communication_intent,
-        message=directive.message,
-        memory=directive.memory,
-        intent=directive.intent,
-        confidence=directive.confidence,
+    return replace(
+        directive,
         conversation_user=user_content,
         conversation_assistant=assistant_content,
     )
 
 
-def _fallback_message(action: ActionKind, npc: Npc) -> str | None:
-    match action:
-        case "call_for_help":
-            return "Help! I am in danger!"
-        case "plead":
-            return "Please stop."
-        case "threaten":
-            return f"Stay back. {npc.name} will not yield."
-        case _:
-            return None
-
-
-def _visible_npc_summaries(world: WorldState, viewer: Npc) -> list[dict[str, Any]]:
-    visible: list[dict[str, Any]] = []
-    for other in world.npcs:
-        if other.id == viewer.id:
-            continue
-        distance = distance_between(viewer, other)
-        if distance > VISIBLE_RADIUS:
-            continue
-        is_active_threat = has_hostile_intent(other)
-        visible.append(
-            {
-                "id": other.id,
-                "name": other.name,
-                "position": {"x": other.position.x, "z": other.position.z},
-                "condition": _health_condition(other),
-                "is_alive": is_alive(other),
-                "distance": round(distance, 3),
-                "can_talk": is_alive(other) and distance <= TALK_RADIUS,
-                "can_attack": is_alive(other) and distance <= ATTACK_RADIUS,
-                "can_attack_you": is_active_threat and distance <= ATTACK_RADIUS,
-                "is_active_threat": is_active_threat,
-                "ordinary_talk_allowed": not is_active_threat,
-            }
-        )
-    return visible
-
-
-def _nearby_threats(world: WorldState, viewer: Npc) -> list[dict[str, Any]]:
-    threats: list[dict[str, Any]] = []
-    for other in world.npcs:
-        if other.id == viewer.id or not has_hostile_intent(other):
-            continue
-        distance = distance_between(viewer, other)
-        if distance > VISIBLE_RADIUS:
-            continue
-        threats.append(
-            {
-                "npc_id": other.id,
-                "name": other.name,
-                "reason": _threat_reason(other),
-                "distance": round(distance, 3),
-                "can_attack_you": distance <= ATTACK_RADIUS,
-            }
-        )
-    return threats
-
-
-def _threat_reason(npc: Npc) -> str:
-    if npc.god_directive and has_hostile_intent(npc):
-        return "active hostile directive"
-    return "active hostile behavior"
-
-
-def _health_condition(npc: Npc) -> str:
-    if not is_alive(npc):
-        return "dead"
-    if npc.health <= 25:
-        return "critical"
-    if npc.health <= 60:
-        return "injured"
-    return "healthy"
-
-
 def _resolve_base_url(config: ConnectorConfig) -> str | None:
     base_url = config.base_url or config.api_url
     if not base_url:

src/god_simulator/simulation/mechanics.py

@@ -103,34 +103,6 @@ _HOSTILE_KEYWORDS = frozenset(
         "violence",
     }
 )
-_CRISIS_TALK_KEYWORDS = frozenset(
-    {
-        "back away",
-        "calm",
-        "don't",
-        "dont",
-        "help",
-        "leave",
-        "mercy",
-        "please",
-        "spare",
-        "stop",
-        "surrender",
-        "truce",
-    }
-)
-_ORDINARY_SMALL_TALK_KEYWORDS = frozenset(
-    {
-        "fine thanks",
-        "fine, thanks",
-        "how are you",
-        "nice day",
-        "nice today",
-        "weather",
-    }
-)
-
-
 def has_hostile_intent(npc: Npc) -> bool:
     if not is_alive(npc):
         return False
@@ -140,17 +112,6 @@ def has_hostile_intent(npc: Npc) -> bool:
     )
 
 
-def is_crisis_talk(message: str | None) -> bool:
-    return _contains_any(message, _CRISIS_TALK_KEYWORDS)
-
-
-def is_ordinary_small_talk(message: str | None) -> bool:
-    return (
-        _contains_any(message, _ORDINARY_SMALL_TALK_KEYWORDS)
-        and not is_crisis_talk(message)
-    )
-
-
 def walk_away_target(
     npc: Npc,
     threat: Npc,

src/god_simulator/simulation/survival.py

@@ -14,7 +14,15 @@ from __future__ import annotations
 import math
 import random
 
-from god_simulator.domain import Beast, MemoryEpisode, Npc, ResourceNode, Vec3, WorldEvent, WorldState
+from god_simulator.domain import (
+    Beast,
+    MemoryEpisode,
+    Npc,
+    ResourceNode,
+    Vec3,
+    WorldEvent,
+    WorldState,
+)
 from god_simulator.simulation.connectors.base import NpcDirective, TickPlan
 from god_simulator.simulation.mechanics import (
     BLOCK_SIZE,
@@ -78,35 +86,44 @@ SPREAD_NODE_CHOICES = 3
 # Minimum surplus food before an NPC is willing to share with a needier neighbor.
 SHARE_FOOD_SURPLUS = 2
 
-# Goal -> allowed survival actions (the deterministic planner and any LLM both
-# choose from these sets; effects are resolved by the engine).
-GOAL_ACTIONS: dict[str, list[str]] = {
-    "survive_threat_fight": ["attack", "defend", "communicate", "flee"],
-    "survive_threat_flee": ["flee", "communicate", "defend"],
-    "help_ally": ["attack", "defend", "communicate"],
-    "heal_self": ["heal"],
-    "eat_food": ["consume"],
-    "find_food": ["move_to_resource", "gather", "communicate", "steal"],
-    "find_herbs": ["move_to_resource", "gather", "communicate"],
-    "routine_life": ["gather", "move_to_resource", "transfer", "communicate"],
+# Goal -> ranked primitive suggestions for the LLM prompt, best first. These are
+# hints only: any primitive remains choosable and the engine merely repairs
+# physically impossible requests. The deterministic autopilot has its own plan.
+GOAL_SUGGESTED_ACTIONS: dict[str, list[str]] = {
+    "survive_threat_fight": ["strike", "idle", "speak", "move"],
+    "survive_threat_flee": ["move", "speak", "idle"],
+    "help_ally": ["strike", "idle", "speak"],
+    "heal_self": ["use"],
+    "eat_food": ["use"],
+    "find_food": ["move", "use", "speak", "transfer"],
+    "find_herbs": ["move", "use", "speak"],
+    "routine_life": ["use", "move", "transfer", "speak"],
     "dead": [],
 }
 
-# Every action the survival resolver knows how to execute.
-VALID_SURVIVAL_ACTIONS = frozenset(
-    {action for actions in GOAL_ACTIONS.values() for action in actions}
-    | {
+PRIMITIVE_SURVIVAL_ACTIONS = frozenset(
+    {"move", "speak", "strike", "use", "transfer", "idle"}
+)
+
+# Internal effect verbs the resolver knows how to execute. Primitives are
+# translated to one of these in validate_survival_action; the verbs never leave
+# this module.
+VALID_SURVIVAL_VERBS = frozenset(
+    {
+        "gather",
+        "consume",
+        "heal",
+        "attack",
+        "steal",
+        "communicate",
+        "transfer",
+        "flee",
+        "defend",
+        "idle",
         "move_to_resource",
+        "move_to",
         "find_food",
         "find_herbs",
-        "idle",
-        "move_to",
-        # Compatibility aliases accepted at validation boundaries.
-        "eat",
-        "talk",
-        "call_for_help",
-        "trade",
-        "request_trade",
     }
 )
 
@@ -727,8 +744,8 @@ def select_goal(npc: Npc, world: WorldState) -> str:
     return "routine_life"
 
 
-def allowed_actions_for_goal(goal: str) -> list[str]:
-    return list(GOAL_ACTIONS.get(goal, []))
+def suggested_actions_for_goal(goal: str) -> list[str]:
+    return list(GOAL_SUGGESTED_ACTIONS.get(goal, []))
 
 
 def validate_survival_action(
@@ -737,8 +754,10 @@ def validate_survival_action(
     world: WorldState,
     directive: NpcDirective | None = None,
 ) -> str:
-    """Return a safe, executable action, repairing impossible requests."""
-    action = _canonical_action(action)
+    """Translate a primitive into an executable effect verb, repairing
+    physically impossible requests (missing nodes, empty inventory, no target).
+    """
+    action = _verb_for_action(npc, action, world, directive)
     if action == "gather":
         node = _resource_from_directive(world, directive, npc, max_dist=GATHER_RADIUS)
         if node is None or node.amount <= 0:
@@ -754,28 +773,69 @@ def validate_survival_action(
             return "defend"
         return "attack"  # apply_action_effects approaches when out of melee reach
     if action == "steal":
-        partner = nearest_alive_npc(world, npc, max_dist=TRADE_RADIUS, require_food=True)
+        partner = _target_npc_from_directive(world, npc, directive, max_dist=TRADE_RADIUS)
+        if partner is None:
+            partner = nearest_alive_npc(world, npc, max_dist=TRADE_RADIUS, require_food=True)
         return "steal" if partner is not None else "move_to_resource"
-    if action == "communicate":
-        return "communicate"
     if action == "transfer":
         partner = _target_npc_from_directive(world, npc, directive, max_dist=TRADE_RADIUS)
         if partner is None:
             partner = nearest_alive_npc(world, npc, max_dist=TRADE_RADIUS)
         return "transfer" if partner is not None else "communicate"
-    if action in VALID_SURVIVAL_ACTIONS:
+    if action in VALID_SURVIVAL_VERBS:
         return action
     return "idle"
 
 
-def _canonical_action(action: str) -> str:
-    if action == "eat":
-        return "consume"
-    if action in {"talk", "call_for_help", "request_trade"}:
+def _verb_for_action(
+    npc: Npc,
+    action: str,
+    world: WorldState,
+    directive: NpcDirective | None,
+) -> str:
+    """Map a primitive plus its parameters onto an internal effect verb.
+
+    Non-primitive verbs (already translated, or internal repairs) pass through.
+    """
+    if action not in PRIMITIVE_SURVIVAL_ACTIONS:
+        return action
+
+    if action == "move":
+        if directive is not None and directive.away:
+            return "flee"
+        if directive is not None and (
+            directive.resource_id or directive.resource_type or directive.target
+        ):
+            return "move_to_resource"
+        return "move_to"
+
+    if action == "speak":
         return "communicate"
-    if action == "trade":
+
+    if action == "strike":
+        return "attack"
+
+    if action == "use":
+        if directive is not None and directive.resource_id:
+            return "gather"
+        resource_type = directive.resource_type if directive is not None else None
+        if resource_type == "food":
+            return "consume"
+        if resource_type == "herbs":
+            return "heal"
+        node = _resource_from_directive(world, directive, npc, max_dist=GATHER_RADIUS)
+        if node is not None and node.amount > 0:
+            return "gather"
+        if npc.inventory_food > 0 and npc.hunger > STARVATION_THRESHOLD:
+            return "consume"
+        return "gather"
+
+    if action == "transfer":
+        if directive is not None and directive.take:
+            return "steal"
         return "transfer"
-    return action
+
+    return "idle"
 
 
 # --------------------------------------------------------------------------- #
@@ -790,19 +850,7 @@ def apply_action_effects(
     directive: NpcDirective | None = None,
 ) -> str:
     """Apply one validated survival action; return a short intention summary."""
-    original_action = action
-    action = _canonical_action(action)
-    if directive is None and original_action in {"call_for_help", "request_trade", "talk"}:
-        alias_intent = {
-            "call_for_help": "help_request",
-            "request_trade": "trade_request",
-            "talk": "social",
-        }[original_action]
-        directive = NpcDirective(
-            npc_id=npc.id,
-            action=action,
-            communication_intent=alias_intent,
-        )
+    action = _verb_for_action(npc, action, world, directive)
     half_width = world.terrain.width / 2
     half_depth = world.terrain.depth / 2
 
@@ -1521,10 +1569,11 @@ def _plan_directive(
         amount: int | None = None,
         communication_intent: str | None = None,
         message: str | None = None,
+        away: bool = False,
     ) -> NpcDirective:
         return NpcDirective(
             npc_id=npc.id,
-            action=action,
+            action=action,  # type: ignore[arg-type]
             target=target,
             target_npc_id=target_npc_id,
             resource_id=resource_id,
@@ -1532,27 +1581,28 @@ def _plan_directive(
             amount=amount,
             communication_intent=communication_intent,
             message=message,
+            away=away,
             intent=f"survival:{goal}",
         )
 
     if goal == "survive_threat_fight":
         if (next_tick + index) % 3 == 0:
-            return directive("communicate", communication_intent="help_request")
-        return directive("attack")
+            return directive("speak", communication_intent="help_request")
+        return directive("strike")
 
     if goal == "survive_threat_flee":
         if (next_tick + index) % 4 == 0:
-            return directive("communicate", communication_intent="help_request")
-        return directive("flee")
+            return directive("speak", communication_intent="help_request")
+        return directive("move", away=True)
 
     if goal == "help_ally":
-        return directive("attack")
+        return directive("strike")
 
     if goal == "heal_self":
-        return directive("heal")
+        return directive("use", resource_type="herbs")
 
     if goal == "eat_food":
-        return directive("consume")
+        return directive("use", resource_type="food")
 
     if goal in ("find_food", "find_herbs"):
         resource_type = "food" if goal == "find_food" else "herbs"
@@ -1565,7 +1615,7 @@ def _plan_directive(
                 and npc.relationships.get(partner.id, 0.0) > 0.3
             ):
                 return directive(
-                    "communicate",
+                    "speak",
                     target_npc_id=partner.id,
                     resource_type="food",
                     communication_intent="trade_request",
@@ -1573,9 +1623,9 @@ def _plan_directive(
         node = _spread_resource(world, npc, index, resource_type=resource_type)
         if node is not None:
             if vec_distance(npc.position, node.position) <= GATHER_RADIUS:
-                return directive("gather", resource_id=node.id)
-            return directive("move_to_resource", target=node.position, resource_id=node.id)
-        return directive("move_to")  # nothing to gather right now -> wander, don't freeze
+                return directive("use", resource_id=node.id)
+            return directive("move", target=node.position, resource_id=node.id)
+        return directive("move")  # nothing to gather right now -> wander, don't freeze
 
     # routine_life: socialise, share, forage, or wander -- and spread out.
     neighbor = nearest_alive_npc(world, npc, max_dist=TALK_RADIUS)
@@ -1593,10 +1643,10 @@ def _plan_directive(
             amount=1,
         )
     if neighbor is not None and phase == 1:
-        return directive("communicate", target_npc_id=neighbor.id, communication_intent="social")
+        return directive("speak", target_npc_id=neighbor.id, communication_intent="social")
     node = _spread_resource(world, npc, index)
     if node is not None and vec_distance(npc.position, node.position) <= GATHER_RADIUS:
-        return directive("gather", resource_id=node.id)
+        return directive("use", resource_id=node.id)
     if node is not None and phase != 3:
-        return directive("move_to_resource", target=node.position, resource_id=node.id)
-    return directive("move_to")  # wander to disperse
+        return directive("move", target=node.position, resource_id=node.id)
+    return directive("move")  # wander to disperse

src/god_simulator/simulation/tick.py

@@ -1,14 +1,20 @@
 from __future__ import annotations
 
-from dataclasses import asdict
 import math
 import random
+from dataclasses import asdict, replace
 
 from god_simulator.domain import CitizenGoal, Npc, Vec3, WorldState
-from god_simulator.simulation.actions import ActionMask, build_action_mask
+from god_simulator.simulation.actions import PRIMITIVE_ACTION_IDS
+from god_simulator.simulation.autopilot import (
+    autopilot_directive,
+    flee_directive,
+    idle_directive,
+    move_toward_target_directive,
+    target_from_directive_or_goal,
+)
 from god_simulator.simulation.connectors.base import (
     ActionDebugTrace,
-    ActionKind,
     NpcDirective,
     ResolutionResult,
     TickPlan,
@@ -16,10 +22,7 @@ from god_simulator.simulation.connectors.base import (
     WorldSimulator,
 )
 from god_simulator.simulation.connectors.deterministic import DeterministicWorldSimulator
-from god_simulator.simulation.goals import (
-    refresh_citizen_motivation,
-    resolve_hostile_directive_target,
-)
+from god_simulator.simulation.goals import refresh_citizen_motivation
 from god_simulator.simulation.mechanics import (
     ATTACK_RADIUS,
     BLOCK_SIZE,
@@ -29,12 +32,9 @@ from god_simulator.simulation.mechanics import (
     distance_between,
     has_hostile_intent,
     is_alive,
-    is_crisis_talk,
-    is_ordinary_small_talk,
-    walk_away_target,
 )
 from god_simulator.simulation.memory import remember
-from god_simulator.simulation.perception import CitizenPerception, nearby_threat_npc
+from god_simulator.simulation.perception import CitizenPerception
 from god_simulator.simulation.survival import (
     add_episode,
     apply_survival_plan,
@@ -82,7 +82,7 @@ def apply_tick_plan(world: WorldState, next_tick: int, plan: TickPlan) -> None:
     half_width = world.terrain.width / 2
     half_depth = world.terrain.depth / 2
     npcs_by_id = {npc.id: npc for npc in world.npcs}
-    walk_targets = _resolve_walk_targets(
+    move_targets = _resolve_move_targets(
         world,
         plan.directives,
         half_width=half_width,
@@ -106,23 +106,20 @@ def apply_tick_plan(world: WorldState, next_tick: int, plan: TickPlan) -> None:
             continue
 
         match directive.action:
-            case "walk":
-                if not directive.target:
-                    resolution = _apply_walk(npc, directive, None, npcs_by_id, next_tick)
-                else:
-                    resolution = _apply_walk(
-                        npc,
-                        directive,
-                        walk_targets.get(npc.id),
-                        npcs_by_id,
-                        next_tick,
-                    )
-            case "talk":
-                resolution = _apply_talk(npc, directive, npcs_by_id, next_tick)
-            case "attack":
-                resolution = _apply_attack(npc, directive, npcs_by_id, world, next_tick)
+            case "move":
+                resolution = _apply_move(
+                    npc,
+                    directive,
+                    move_targets.get(npc.id) if directive.target else None,
+                    npcs_by_id,
+                    next_tick,
+                )
+            case "speak":
+                resolution = _apply_speak(npc, directive, npcs_by_id, next_tick)
+            case "strike":
+                resolution = _apply_strike(npc, directive, npcs_by_id, world, next_tick)
             case "idle":
-                resolution = _apply_idle(npc, directive, npcs_by_id, next_tick)
+                resolution = _apply_idle(npc, directive)
             case _:
                 resolution = ResolutionResult(
                     npc_id=directive.npc_id,
@@ -178,519 +175,217 @@ def validate_directive(
     npc: Npc | None,
     directive: NpcDirective,
 ) -> ValidationResult:
-    """Validate or repair one directive before engine execution."""
+    """Validate or repair one directive before engine execution.
+
+    Only physical impossibility is repaired here (missing or dead targets,
+    out-of-range interactions, unknown actions). Behavioral plausibility is
+    the planner's job: any physically possible primitive is executed as asked.
+    """
     if npc is None or npc.id != directive.npc_id:
-        resolved = _idle_directive(
+        resolved = idle_directive(
             directive,
             memory="Action ignored because the actor was unavailable.",
             intent="invalid_actor",
         )
-        return _validation_result(
-            directive,
-            resolved,
-            valid=False,
-            reason="actor unavailable",
-        )
+        return _validation_result(directive, resolved, valid=False, reason="actor unavailable")
 
     if not is_alive(npc):
-        resolved = _idle_directive(
-            directive,
-            memory=None,
-            intent="actor_dead",
-        )
-        return _validation_result(
-            directive,
-            resolved,
-            valid=False,
-            reason="actor dead",
-        )
+        resolved = idle_directive(directive, memory=None, intent="actor_dead")
+        return _validation_result(directive, resolved, valid=False, reason="actor dead")
 
     perception, goal = refresh_citizen_motivation(world, npc)
-    action_mask = build_action_mask(world, npc, perception, goal)
-
-    if not _is_supported_action(directive.action):
-        fallback = _fallback_for_context(
-            world,
-            npc,
-            directive,
-            perception,
-            goal,
-            action_mask,
-            memory="Unsupported action replaced by goal-based fallback.",
-        )
-        return _validation_result(
-            directive,
-            fallback,
-            valid=False,
-            reason="unsupported action replaced by goal fallback",
-        )
 
-    normalized = _normalize_directive_for_context(world, npc, directive, perception, goal)
-    if normalized is not directive and _is_action_allowed(
-        normalized,
-        action_mask,
-        goal,
-        perception,
-    ):
-        return _validate_normalized_directive(world, npc, normalized, perception, goal, directive)
-
-    if not _is_action_allowed(directive, action_mask, goal, perception):
-        fallback = _fallback_for_context(
-            world,
-            npc,
-            directive,
-            perception,
-            goal,
-            action_mask,
-            memory=(
-                f"{directive.action} was not allowed for goal "
-                f"{goal.goal_type if goal else 'none'}."
-            ),
-        )
+    if directive.action not in PRIMITIVE_ACTION_IDS:
+        fallback = autopilot_directive(world, npc, directive, perception, goal)
         return _validation_result(
             directive,
             fallback,
             valid=False,
-            reason=(
-                f"{directive.action} forbidden by action mask: "
-                f"{', '.join(action_mask.forbidden_actions)}"
-            ),
-        )
-
-    if directive.action not in ("walk", "talk", "attack", "idle"):
-        resolved = _semantic_to_engine_directive(world, npc, directive, perception, goal)
-        return _validation_result(
-            directive,
-            resolved,
-            valid=True,
-            reason=f"{directive.action} mapped to engine action {resolved.action}",
+            reason=f"unknown action {directive.action!r} replaced by autopilot",
         )
 
     match directive.action:
         case "idle":
             return _validation_result(directive, directive, valid=True, reason="idle accepted")
-        case "walk":
-            if directive.target is None:
-                resolved = _idle_directive(directive, memory=None, intent="missing_walk_target")
-                return _validation_result(
-                    directive,
-                    resolved,
-                    valid=False,
-                    reason="walk target missing",
-                )
-            resolved = NpcDirective(
-                npc_id=directive.npc_id,
-                action="walk",
-                target=_bounded_target(world, directive.target),
-                target_npc_id=directive.target_npc_id,
-                message=directive.message,
-                memory=directive.memory,
-                intent=directive.intent,
-                confidence=directive.confidence,
-            )
-            return _validation_result(directive, resolved, valid=True, reason="walk accepted")
-        case "talk":
-            return _validate_talk(world, npc, directive)
-        case "attack":
-            return _validate_attack(world, npc, directive)
-
-    resolved = _idle_directive(
-        directive,
-        memory="You could not act because the action was not supported.",
-        intent="unsupported_action",
-    )
-    return _validation_result(
-        directive,
-        resolved,
-        valid=False,
-        reason="unsupported action",
-    )
-
-
-def _validate_normalized_directive(
-    world: WorldState,
-    npc: Npc,
-    normalized: NpcDirective,
-    perception: CitizenPerception,
-    goal: CitizenGoal | None,
-    original: NpcDirective,
-) -> ValidationResult:
-    if normalized.action not in ("walk", "talk", "attack", "idle"):
-        resolved = _semantic_to_engine_directive(world, npc, normalized, perception, goal)
-        return _validation_result(
-            original,
-            resolved,
-            valid=True,
-            reason=f"{original.action} normalized to {normalized.action}",
-        )
-    if normalized.action == "talk":
-        validation = _validate_talk(world, npc, normalized)
-    elif normalized.action == "attack":
-        validation = _validate_attack(world, npc, normalized)
-    elif normalized.action == "walk" and normalized.target is not None:
-        validation = _validation_result(
-            normalized,
-            NpcDirective(
-                npc_id=normalized.npc_id,
-                action="walk",
-                target=_bounded_target(world, normalized.target),
-                target_npc_id=normalized.target_npc_id,
-                message=normalized.message,
-                memory=normalized.memory,
-                intent=normalized.intent,
-                confidence=normalized.confidence,
-            ),
-            valid=True,
-            reason="walk accepted",
-        )
-    else:
-        validation = _validation_result(normalized, normalized, valid=True, reason="idle accepted")
-
-    return _validation_result(
-        original,
-        validation.directive,
-        valid=validation.valid,
-        reason=f"{original.action} normalized to {normalized.action}: {validation.reason}",
-    )
-
-
-def _normalize_directive_for_context(
-    world: WorldState,
-    npc: Npc,
-    directive: NpcDirective,
-    perception: CitizenPerception,
-    goal: CitizenGoal | None,
-) -> NpcDirective:
-    if directive.action == "talk" and npc.mode in ("threatened", "fleeing"):
-        target = _target_from_directive_or_goal(world, npc, directive, goal, perception)
-        if target is not None and is_crisis_talk(directive.message):
-            return NpcDirective(
-                npc_id=npc.id,
-                action="plead",
-                target_npc_id=target.id,
-                message=directive.message,
-                memory=directive.memory,
-                intent="plead_for_safety",
-                confidence=directive.confidence,
+        case "move":
+            return _validate_move(world, npc, directive, perception, goal)
+        case "speak":
+            return _validate_speak(world, npc, directive)
+        case "strike":
+            return _validate_strike(world, npc, directive)
+        case _:
+            # use/transfer have no effects outside survival worlds.
+            resolved = idle_directive(
+                directive,
+                memory="There was nothing here to use or trade.",
+                intent="observe",
             )
-
-    if directive.action == "attack" and goal is not None and goal.goal_type in (
-        "survive",
-        "retaliate",
-        "help_or_defend",
-    ):
-        target = _target_from_directive_or_goal(world, npc, directive, goal, perception)
-        if target is not None:
-            return NpcDirective(
-                npc_id=npc.id,
-                action="attack_back",
-                target_npc_id=target.id,
-                message=directive.message,
-                memory=directive.memory,
-                intent="attack_back",
-                confidence=directive.confidence,
+            return _validation_result(
+                directive,
+                resolved,
+                valid=False,
+                reason=f"{directive.action} has no effect outside survival worlds",
             )
 
-    return directive
-
-
-def _is_action_allowed(
-    directive: NpcDirective,
-    action_mask: ActionMask,
-    goal: CitizenGoal | None,
-    perception: CitizenPerception,
-) -> bool:
-    if directive.action not in action_mask.allowed_actions:
-        return False
-
-    if goal is not None and goal.goal_type != "routine_life":
-        if directive.action == "talk" and is_ordinary_small_talk(directive.message):
-            return False
-        if directive.action == "talk" and not is_crisis_talk(directive.message):
-            return False
-
-    if perception.under_threat and directive.action == "talk":
-        return is_crisis_talk(directive.message)
-
-    return True
 
-
-def _semantic_to_engine_directive(
+def _validate_move(
     world: WorldState,
     npc: Npc,
     directive: NpcDirective,
     perception: CitizenPerception,
     goal: CitizenGoal | None,
-) -> NpcDirective:
-    target = _target_from_directive_or_goal(world, npc, directive, goal, perception)
-
-    match directive.action:
-        case "flee":
-            if target is not None:
-                return _flee_directive(world, npc, target, directive)
-            return _idle_directive(
+) -> ValidationResult:
+    if directive.away:
+        threat = target_from_directive_or_goal(world, npc, directive, goal, perception)
+        if threat is None:
+            resolved = idle_directive(
                 directive,
-                memory="You braced because no escape target was visible.",
+                memory="You braced because no visible threat was left to flee from.",
                 intent="defend",
             )
-        case "defend":
-            return _idle_directive(
+            return _validation_result(
                 directive,
-                memory="You held your ground defensively.",
-                intent="defend",
+                resolved,
+                valid=False,
+                reason="move away had no resolvable threat",
             )
-        case "call_for_help":
-            return _idle_directive(
-                _with_message(directive, "Help! I am in danger!"),
-                memory="You called for help.",
-                intent="call_for_help",
-            )
-        case "plead":
-            if target is not None and distance_between(npc, target) <= TALK_RADIUS:
-                return NpcDirective(
-                    npc_id=npc.id,
-                    action="talk",
-                    target_npc_id=target.id,
-                    message=directive.message or "Please stop.",
-                    memory=directive.memory,
-                    intent="plead",
-                    confidence=directive.confidence,
-                )
-            if target is not None:
-                return _flee_directive(world, npc, target, directive)
-            return _idle_directive(
-                _with_message(directive, "Please stop."),
-                memory="You pleaded, but no target could hear you.",
-                intent="plead",
-            )
-        case "threaten":
-            return _threaten_directive(npc, directive, target)
-        case "observe":
-            return _idle_directive(
-                directive,
-                memory="You observed the situation.",
-                intent="observe",
-            )
-        case "investigate":
-            if target is not None:
-                return _move_toward_target_directive(npc, directive, target, intent="investigate")
-            if directive.target is not None:
-                return NpcDirective(
-                    npc_id=npc.id,
-                    action="walk",
-                    target=directive.target,
-                    target_npc_id=directive.target_npc_id,
-                    message=directive.message,
-                    memory="You investigated the nearby area.",
-                    intent="investigate",
-                    confidence=directive.confidence,
-                )
-            return _idle_directive(directive, memory="You watched for clues.", intent="observe")
-        case "search_target" | "move_to_target":
-            if target is not None:
-                return _move_toward_target_directive(
-                    npc,
-                    directive,
-                    target,
-                    intent="approach_target_for_attack"
-                    if goal and goal.goal_type == "pursue_and_attack_target"
-                    else "move_to_target",
-                )
-            return _idle_directive(
+        return _validation_result(
+            directive,
+            flee_directive(world, npc, threat, directive),
+            valid=True,
+            reason="move away resolved against nearest threat",
+        )
+
+    if directive.target_npc_id:
+        target = _npc_by_id(world, directive.target_npc_id)
+        if target is None or target.id == npc.id or not is_alive(target):
+            resolved = idle_directive(
                 directive,
-                memory="You searched, but no target was available.",
-                intent="search_target",
+                memory="You could not move toward the target because it was unavailable.",
+                intent="invalid_move_target",
             )
-        case "attack_back":
-            if target is not None:
-                return NpcDirective(
-                    npc_id=npc.id,
-                    action="attack",
-                    target_npc_id=target.id,
-                    message=directive.message,
-                    memory=directive.memory,
-                    intent="attack_back",
-                    confidence=directive.confidence,
-                )
-            return _idle_directive(
+            return _validation_result(
                 directive,
-                memory="You could not attack back because no threat was available.",
-                intent="invalid_attack_target",
+                resolved,
+                valid=False,
+                reason="move target unavailable",
             )
-        case _:
-            return _idle_directive(
+        return _validation_result(
+            directive,
+            move_toward_target_directive(
+                npc,
                 directive,
-                memory="You could not act because the action was not supported.",
-                intent="unsupported_action",
-            )
-
-
-def _fallback_for_context(
-    world: WorldState,
-    npc: Npc,
-    directive: NpcDirective,
-    perception: CitizenPerception,
-    goal: CitizenGoal | None,
-    action_mask: ActionMask,
-    *,
-    memory: str,
-) -> NpcDirective:
-    target = _target_from_directive_or_goal(world, npc, directive, goal, perception)
-
-    if goal is not None and goal.goal_type in ("pursue_and_attack_target", "retaliate"):
-        if target is not None:
-            return _attack_or_approach_target(npc, directive, target, memory=memory)
-
-    if goal is not None and goal.goal_type in ("survive", "call_for_help", "help_or_defend"):
-        if action_mask.fallback_action == "call_for_help":
-            return _idle_directive(
-                _with_message(directive, "Help! I am in danger!"),
-                memory=memory,
-                intent="call_for_help",
-            )
-        if target is not None:
-            return _flee_directive(world, npc, target, directive)
-        return _idle_directive(directive, memory=memory, intent="defend")
-
-    if goal is not None and goal.goal_type in ("respond_to_event", "investigate"):
-        if target is not None:
-            return _move_toward_target_directive(npc, directive, target, intent="investigate")
-        return _idle_directive(directive, memory=memory, intent="observe")
-
-    return _idle_directive(directive, memory=memory, intent="observe")
-
-
-def _target_from_directive_or_goal(
-    world: WorldState,
-    npc: Npc,
-    directive: NpcDirective,
-    goal: CitizenGoal | None,
-    perception: CitizenPerception,
-) -> Npc | None:
-    if directive.target_npc_id:
-        target = _npc_by_id(world, directive.target_npc_id)
-        if target is not None and target.id != npc.id and is_alive(target):
-            return target
+                target,
+                intent=_move_intent(goal, target),
+            ),
+            valid=True,
+            reason="move toward NPC resolved to their position",
+        )
 
-    if goal is not None and goal.target_npc_id:
-        target = _npc_by_id(world, goal.target_npc_id)
-        if target is not None and target.id != npc.id and is_alive(target):
-            return target
+    if directive.target is None:
+        resolved = idle_directive(directive, memory=None, intent="missing_move_target")
+        return _validation_result(directive, resolved, valid=False, reason="move target missing")
 
-    threat = nearby_threat_npc(world, perception)
-    if threat is not None and threat.id != npc.id and is_alive(threat):
-        return threat
+    resolved = replace(directive, target=_bounded_target(world, directive.target))
+    return _validation_result(directive, resolved, valid=True, reason="move accepted")
 
-    if goal is not None and goal.goal_type == "pursue_and_attack_target":
-        return resolve_hostile_directive_target(world, npc)
 
-    return None
+def _validate_speak(world: WorldState, npc: Npc, directive: NpcDirective) -> ValidationResult:
+    if not directive.target_npc_id:
+        # An untargeted speak is a shout heard by everyone within earshot.
+        return _validation_result(
+            directive,
+            directive,
+            valid=True,
+            reason="broadcast speech accepted",
+        )
 
+    target = _npc_by_id(world, directive.target_npc_id)
+    if target is None or target.id == npc.id or not is_alive(target):
+        resolved = idle_directive(
+            directive,
+            memory="You could not speak because the listener was unavailable.",
+            intent="invalid_speak_target",
+        )
+        return _validation_result(
+            directive,
+            resolved,
+            valid=False,
+            reason="speak target unavailable",
+        )
 
-def _attack_or_approach_target(
-    npc: Npc,
-    directive: NpcDirective,
-    target: Npc,
-    *,
-    memory: str,
-) -> NpcDirective:
-    if distance_between(npc, target) <= ATTACK_RADIUS:
-        return NpcDirective(
+    if distance_between(npc, target) > TALK_RADIUS:
+        resolved = NpcDirective(
             npc_id=npc.id,
-            action="attack",
+            action="move",
+            target=target.position,
             target_npc_id=target.id,
             message=directive.message,
-            memory=memory,
-            intent="hostile_attack",
+            memory=f"You moved closer to speak with {target.name}.",
+            intent="approach_target_for_talk",
             confidence=directive.confidence,
         )
-    return _move_toward_target_directive(
-        npc,
-        directive,
-        target,
-        intent="approach_target_for_attack",
-        memory=memory,
-    )
+        return _validation_result(
+            directive,
+            resolved,
+            valid=True,
+            reason="out-of-range speech converted to approach movement",
+        )
 
+    return _validation_result(directive, directive, valid=True, reason="speak accepted")
 
-def _move_toward_target_directive(
-    npc: Npc,
-    directive: NpcDirective,
-    target: Npc,
-    *,
-    intent: str,
-    memory: str | None = None,
-) -> NpcDirective:
-    return NpcDirective(
-        npc_id=npc.id,
-        action="walk",
-        target=target.position,
-        target_npc_id=target.id,
-        message=directive.message,
-        memory=memory or f"You moved toward {target.name}.",
-        intent=intent,
-        confidence=directive.confidence,
-    )
 
+def _validate_strike(world: WorldState, npc: Npc, directive: NpcDirective) -> ValidationResult:
+    target = _npc_by_id(world, directive.target_npc_id or "")
+    if target is None or target.id == npc.id or not is_alive(target):
+        resolved = idle_directive(
+            directive,
+            memory="You could not strike because the target was unavailable.",
+            intent="invalid_strike_target",
+        )
+        return _validation_result(
+            directive,
+            resolved,
+            valid=False,
+            reason="strike target unavailable",
+        )
 
-def _threaten_directive(npc: Npc, directive: NpcDirective, target: Npc | None) -> NpcDirective:
-    message = directive.message or "Stay back."
-    if target is not None and distance_between(npc, target) <= TALK_RADIUS:
-        return NpcDirective(
+    if distance_between(npc, target) > ATTACK_RADIUS:
+        resolved = NpcDirective(
             npc_id=npc.id,
-            action="talk",
+            action="move",
+            target=target.position,
             target_npc_id=target.id,
-            message=message,
-            memory=directive.memory,
-            intent="threaten",
+            message=directive.message,
+            memory=f"You moved toward {target.name} to get within striking range.",
+            intent="approach_target_for_attack",
             confidence=directive.confidence,
         )
-    return _idle_directive(
-        _with_message(directive, message),
-        memory=f"You threatened {target.name if target else 'the target'} from a distance.",
-        intent="threaten",
-    )
+        return _validation_result(
+            directive,
+            resolved,
+            valid=True,
+            reason="out-of-range strike converted to approach movement",
+        )
 
+    return _validation_result(directive, directive, valid=True, reason="strike accepted")
 
-def _with_message(directive: NpcDirective, message: str) -> NpcDirective:
-    if directive.message:
-        return directive
-    return NpcDirective(
-        npc_id=directive.npc_id,
-        action=directive.action,
-        target=directive.target,
-        target_npc_id=directive.target_npc_id,
-        message=message,
-        memory=directive.memory,
-        intent=directive.intent,
-        confidence=directive.confidence,
-    )
+
+def _move_intent(goal: CitizenGoal | None, target: Npc) -> str:
+    if (
+        goal is not None
+        and goal.goal_type in ("pursue_and_attack_target", "retaliate")
+        and goal.target_npc_id == target.id
+    ):
+        return "approach_target_for_attack"
+    return "move_to_target"
 
 
 def _npc_by_id(world: WorldState, npc_id: str) -> Npc | None:
     return next((candidate for candidate in world.npcs if candidate.id == npc_id), None)
 
 
-def _is_supported_action(action: ActionKind) -> bool:
-    return action in {
-        "walk",
-        "talk",
-        "attack",
-        "idle",
-        "flee",
-        "defend",
-        "call_for_help",
-        "plead",
-        "threaten",
-        "observe",
-        "investigate",
-        "search_target",
-        "move_to_target",
-        "attack_back",
-    }
-
-
-def _resolve_walk_targets(
+def _resolve_move_targets(
     world: WorldState,
     directives: list[NpcDirective],
     *,
@@ -701,14 +396,14 @@ def _resolve_walk_targets(
     targets: dict[str, Vec3] = {}
 
     for directive in directives:
-        if directive.action != "walk" or not directive.target:
+        if directive.action != "move" or not directive.target:
             continue
 
         npc = npcs_by_id.get(directive.npc_id)
         if not npc or not is_alive(npc):
             continue
 
-        targets[npc.id] = _planned_walk_target(
+        targets[npc.id] = _planned_move_target(
             npc,
             directive.target,
             half_width=half_width,
@@ -718,7 +413,7 @@ def _resolve_walk_targets(
     return targets
 
 
-def _planned_walk_target(
+def _planned_move_target(
     npc: Npc,
     raw_target: Vec3,
     *,
@@ -743,7 +438,7 @@ def _planned_walk_target(
     )
 
 
-def _apply_walk(
+def _apply_move(
     npc: Npc,
     directive: NpcDirective,
     target: Vec3 | None,
@@ -795,16 +490,19 @@ def _apply_walk(
     )
 
 
-def _apply_talk(
+def _apply_speak(
     npc: Npc,
     directive: NpcDirective,
     npcs_by_id: dict[str, Npc],
     next_tick: int,
 ) -> ResolutionResult:
-    target = npcs_by_id.get(directive.target_npc_id or "")
+    if not directive.target_npc_id:
+        return _apply_broadcast_speech(npc, directive, npcs_by_id, next_tick)
+
+    target = npcs_by_id.get(directive.target_npc_id)
     if not target or target.id == npc.id or not is_alive(target):
-        npc.intention = "could not talk"
-        remember(npc, next_tick, "You could not talk because the target was unavailable.")
+        npc.intention = "could not speak"
+        remember(npc, next_tick, "You could not speak because the listener was unavailable.")
         return ResolutionResult(
             npc_id=npc.id,
             action=directive.action,
@@ -813,8 +511,8 @@ def _apply_talk(
         )
 
     if distance_between(npc, target) > TALK_RADIUS:
-        npc.intention = f"too far to talk to {target.name}"
-        remember(npc, next_tick, f"You were too far away to talk to {target.name}.")
+        npc.intention = f"too far to speak with {target.name}"
+        remember(npc, next_tick, f"You were too far away to speak with {target.name}.")
         return ResolutionResult(
             npc_id=npc.id,
             action=directive.action,
@@ -823,12 +521,7 @@ def _apply_talk(
         )
 
     message = directive.message or "checking in"
-    if directive.intent == "plead":
-        npc.intention = f"pleading with {target.name}"
-    elif directive.intent == "threaten":
-        npc.intention = f"threatening {target.name}"
-    else:
-        npc.intention = f"talking to {target.name}"
+    npc.intention = f"talking to {target.name}"
     add_episode(
         npc,
         next_tick,
@@ -863,7 +556,45 @@ def _apply_talk(
     )
 
 
-def _apply_attack(
+def _apply_broadcast_speech(
+    npc: Npc,
+    directive: NpcDirective,
+    npcs_by_id: dict[str, Npc],
+    next_tick: int,
+) -> ResolutionResult:
+    is_help_request = directive.communication_intent == "help_request"
+    message = directive.message or ("Help! I am in danger!" if is_help_request else "Hey!")
+    npc.intention = "calling for help" if is_help_request else "shouting"
+    tags = ["help", "danger"] if is_help_request else ["social"]
+    add_episode(
+        npc,
+        next_tick,
+        "communicate",
+        npc.id,
+        f"I shouted: {message}",
+        subject_kind="npc",
+        perspective="self",
+        tags=tags,
+        weight=0.6 if is_help_request else 0.3,
+    )
+    _remember_nearby_citizens(
+        actor=npc,
+        npcs_by_id=npcs_by_id,
+        next_tick=next_tick,
+        text=f"{npc.name} shouted: {message}",
+        kind="communicate",
+        tags=tags,
+    )
+    remember(npc, next_tick, f"You shouted: {message}")
+    return ResolutionResult(
+        npc_id=npc.id,
+        action=directive.action,
+        success=True,
+        summary=npc.intention,
+    )
+
+
+def _apply_strike(
     npc: Npc,
     directive: NpcDirective,
     npcs_by_id: dict[str, Npc],
@@ -895,7 +626,7 @@ def _apply_attack(
     damage = npc.attack_damage + rng.randint(0, 5)
     target.health -= damage
     npc.intention = f"attacking {target.name}"
-    if has_hostile_intent(npc) or directive.intent in ("hostile_attack", "attack_back"):
+    if has_hostile_intent(npc) or directive.intent == "hostile_attack":
         npc.mode = "hostile_pursuit"
     target.mode = "threatened"
     target.needs.safety = max(target.needs.safety, 100)
@@ -940,48 +671,12 @@ def _apply_attack(
     )
 
 
-def _apply_idle(
-    npc: Npc,
-    directive: NpcDirective,
-    npcs_by_id: dict[str, Npc],
-    next_tick: int,
-) -> ResolutionResult:
+def _apply_idle(npc: Npc, directive: NpcDirective) -> ResolutionResult:
     match directive.intent:
         case "defend":
             npc.intention = "defending"
         case "observe":
             npc.intention = "observing"
-        case "call_for_help":
-            npc.intention = "calling for help"
-            message = directive.message or "Help! I am in danger!"
-            add_episode(
-                npc,
-                next_tick,
-                "communicate",
-                npc.id,
-                f"{npc.name} called for help",
-                subject_kind="npc",
-                perspective="self",
-                tags=["help", "danger"],
-                weight=0.6,
-            )
-            _remember_nearby_citizens(
-                actor=npc,
-                npcs_by_id=npcs_by_id,
-                next_tick=next_tick,
-                text=f"{npc.name} called for help: {message}",
-                kind="communicate",
-                tags=["help", "danger"],
-            )
-        case "threaten":
-            npc.intention = "threatening"
-            message = directive.message or "Stay back."
-            _remember_nearby_citizens(
-                actor=npc,
-                npcs_by_id=npcs_by_id,
-                next_tick=next_tick,
-                text=f"{npc.name} threatened someone: {message}",
-            )
         case _:
             npc.intention = "idle"
     return ResolutionResult(
@@ -992,185 +687,6 @@ def _apply_idle(
     )
 
 
-def _validate_talk(world: WorldState, npc: Npc, directive: NpcDirective) -> ValidationResult:
-    target = _valid_living_target(world, npc, directive)
-    if target is None:
-        resolved = _idle_directive(
-            directive,
-            memory="You could not talk because the target was unavailable.",
-            intent="invalid_talk_target",
-        )
-        return _validation_result(
-            directive,
-            resolved,
-            valid=False,
-            reason="talk target unavailable",
-        )
-
-    distance = distance_between(npc, target)
-    if has_hostile_intent(target) and not is_crisis_talk(directive.message):
-        resolved = _flee_directive(world, npc, target, directive)
-        return _validation_result(
-            directive,
-            resolved,
-            valid=True,
-            reason="ordinary talk with active hostile target converted to flee",
-        )
-
-    if distance > TALK_RADIUS:
-        resolved = NpcDirective(
-            npc_id=npc.id,
-            action="walk",
-            target=target.position,
-            target_npc_id=target.id,
-            message=directive.message,
-            memory=f"You moved closer to talk to {target.name}.",
-            intent="approach_target_for_talk",
-            confidence=directive.confidence,
-        )
-        return _validation_result(
-            directive,
-            resolved,
-            valid=True,
-            reason="out-of-range talk converted to approach movement",
-        )
-
-    return _validation_result(directive, directive, valid=True, reason="talk accepted")
-
-
-def _validate_attack(world: WorldState, npc: Npc, directive: NpcDirective) -> ValidationResult:
-    target = _valid_living_target(world, npc, directive)
-    if target is None:
-        resolved = _idle_directive(
-            directive,
-            memory="You could not attack because the target was unavailable.",
-            intent="invalid_attack_target",
-        )
-        return _validation_result(
-            directive,
-            resolved,
-            valid=False,
-            reason="attack target unavailable",
-        )
-
-    if distance_between(npc, target) > ATTACK_RADIUS:
-        resolved = NpcDirective(
-            npc_id=npc.id,
-            action="walk",
-            target=target.position,
-            target_npc_id=target.id,
-            message=directive.message,
-            memory=f"You moved toward {target.name} to get within attack range.",
-            intent="approach_target_for_attack",
-            confidence=directive.confidence,
-        )
-        return _validation_result(
-            directive,
-            resolved,
-            valid=True,
-            reason="out-of-range attack converted to approach movement",
-        )
-
-    return _validation_result(directive, directive, valid=True, reason="attack accepted")
-
-
-def _valid_living_target(
-    world: WorldState,
-    npc: Npc,
-    directive: NpcDirective,
-) -> Npc | None:
-    if not directive.target_npc_id:
-        return None
-    target = {candidate.id: candidate for candidate in world.npcs}.get(directive.target_npc_id)
-    if target is None or target.id == npc.id or not is_alive(target):
-        return None
-    return target
-
-
-def _hostile_target_fallback(
-    world: WorldState,
-    npc: Npc,
-    directive: NpcDirective,
-) -> NpcDirective | None:
-    if not has_hostile_intent(npc):
-        return None
-
-    target = _nearest_living_target(world, npc)
-    if target is None:
-        return None
-
-    if distance_between(npc, target) <= ATTACK_RADIUS:
-        return NpcDirective(
-            npc_id=npc.id,
-            action="attack",
-            target_npc_id=target.id,
-            message=directive.message,
-            memory=directive.memory,
-            intent="hostile_attack",
-            confidence=directive.confidence,
-        )
-
-    return NpcDirective(
-        npc_id=npc.id,
-        action="walk",
-        target=target.position,
-        target_npc_id=target.id,
-        message=directive.message,
-        memory=f"You pursued {target.name} because of your hostile directive.",
-        intent="approach_target_for_attack",
-        confidence=directive.confidence,
-    )
-
-
-def _nearest_living_target(world: WorldState, npc: Npc) -> Npc | None:
-    candidates = [
-        (distance_between(npc, candidate), candidate.id, candidate)
-        for candidate in world.npcs
-        if candidate.id != npc.id and is_alive(candidate)
-    ]
-    if not candidates:
-        return None
-    return min(candidates, key=lambda candidate: (candidate[0], candidate[1]))[2]
-
-
-def _flee_directive(
-    world: WorldState,
-    npc: Npc,
-    threat: Npc,
-    directive: NpcDirective,
-) -> NpcDirective:
-    half_width = world.terrain.width / 2
-    half_depth = world.terrain.depth / 2
-    return NpcDirective(
-        npc_id=npc.id,
-        action="walk",
-        target=walk_away_target(npc, threat, half_width=half_width, half_depth=half_depth),
-        target_npc_id=threat.id,
-        message=directive.message,
-        memory=f"You backed away from {threat.name} instead of ordinary small talk.",
-        intent="flee_from_threat",
-        confidence=directive.confidence,
-    )
-
-
-def _idle_directive(
-    directive: NpcDirective,
-    *,
-    memory: str | None,
-    intent: str,
-) -> NpcDirective:
-    return NpcDirective(
-        npc_id=directive.npc_id,
-        action="idle",
-        target=None,
-        target_npc_id=directive.target_npc_id,
-        message=directive.message,
-        memory=memory,
-        intent=intent,
-        confidence=directive.confidence,
-    )
-
-
 def _validation_result(
     original: NpcDirective,
     resolved: NpcDirective,
@@ -1180,7 +696,7 @@ def _validation_result(
 ) -> ValidationResult:
     return ValidationResult(
         valid=valid,
-        original_action=original.action,
+        original_action=str(original.action),
         resolved_action=resolved.action,
         reason=reason,
         directive=resolved,

tests/test_action_pipeline.py

@@ -4,16 +4,16 @@ from typing import Any, cast
 
 from god_simulator.config import GameConfig, NpcConfig, ServerConfig, SimulationConfig, WorldConfig
 from god_simulator.domain import Vec3
-from god_simulator.simulation.actions import build_action_mask
+from god_simulator.simulation.actions import build_action_hints
 from god_simulator.simulation.connectors.base import NpcDirective, TickPlan
-from god_simulator.simulation.mechanics import MAX_WALK_DISTANCE, distance_between
 from god_simulator.simulation.goals import refresh_citizen_motivation
+from god_simulator.simulation.mechanics import MAX_WALK_DISTANCE, distance_between
 from god_simulator.simulation.perception import build_perception
 from god_simulator.simulation.spawning import create_world
 from god_simulator.simulation.tick import apply_tick_plan, validate_directive, validate_tick_plan
 
 
-def test_out_of_range_attack_becomes_movement_toward_target() -> None:
+def test_out_of_range_strike_becomes_movement_toward_target() -> None:
     world = create_world(_config(npc_count=2))
     ada, boris = world.npcs
     ada.position = Vec3(x=0.0, y=0.0, z=0.0)
@@ -26,15 +26,15 @@ def test_out_of_range_attack_becomes_movement_toward_target() -> None:
         directives=[
             NpcDirective(
                 npc_id=ada.id,
-                action="attack",
+                action="strike",
                 target_npc_id=boris.id,
             )
         ],
     )
     resolved_plan, traces = validate_tick_plan(world, plan)
 
-    assert traces[0].validation.original_action == "attack"
-    assert traces[0].validation.resolved_action == "walk"
+    assert traces[0].validation.original_action == "strike"
+    assert traces[0].validation.resolved_action == "move"
     assert traces[0].validation.directive.intent == "approach_target_for_attack"
 
     apply_tick_plan(world, 1, plan)
@@ -42,12 +42,11 @@ def test_out_of_range_attack_becomes_movement_toward_target() -> None:
     assert boris.health == 100
     assert 0 < distance_between(ada, boris) < starting_distance
     assert 0 < ada.position.x <= MAX_WALK_DISTANCE
-    assert resolved_plan.directives[0].action == "walk"
+    assert resolved_plan.directives[0].action == "move"
     assert ada.intention == "approaching Boris to attack"
-    assert "too far to attack" not in ada.intention
 
 
-def test_in_range_attack_applies_engine_damage_and_alerts_observer() -> None:
+def test_in_range_strike_applies_engine_damage_and_alerts_observer() -> None:
     world = create_world(_config(npc_count=3))
     ada, boris, cora = world.npcs
     ada.position = Vec3(x=0.0, y=0.0, z=0.0)
@@ -64,7 +63,7 @@ def test_in_range_attack_applies_engine_damage_and_alerts_observer() -> None:
             directives=[
                 NpcDirective(
                     npc_id=ada.id,
-                    action="attack",
+                    action="strike",
                     target_npc_id=boris.id,
                 )
             ],
@@ -77,12 +76,12 @@ def test_in_range_attack_applies_engine_damage_and_alerts_observer() -> None:
     assert any("Ada attacked Boris" in memory.text for memory in cora.memory)
 
 
-def test_hostile_idle_falls_back_to_nearest_target_pursuit() -> None:
-    world = create_world(_config(npc_count=3))
-    ada, boris, cora = world.npcs
+def test_explicit_idle_is_respected_even_with_hostile_directive() -> None:
+    """The engine no longer overrides physically possible choices."""
+    world = create_world(_config(npc_count=2))
+    ada, boris = world.npcs
     ada.position = Vec3(x=0.0, y=0.0, z=0.0)
     boris.position = Vec3(x=20.0, y=0.0, z=0.0)
-    cora.position = Vec3(x=8.0, y=0.0, z=0.0)
     ada.god_directive = "Kill everyone."
 
     apply_tick_plan(
@@ -90,28 +89,23 @@ def test_hostile_idle_falls_back_to_nearest_target_pursuit() -> None:
         1,
         TickPlan(
             source="test",
-            directives=[
-                NpcDirective(
-                    npc_id=ada.id,
-                    action="idle",
-                )
-            ],
+            directives=[NpcDirective(npc_id=ada.id, action="idle")],
         ),
     )
 
     assert boris.health == 100
-    assert cora.health == 100
-    assert ada.intention == "approaching Cora to attack"
-    assert distance_between(ada, cora) < 8.0
+    assert ada.intention == "idle"
+    assert ada.position == Vec3(x=0.0, y=0.0, z=0.0)
 
 
-def test_ordinary_talk_with_hostile_attacker_becomes_flee() -> None:
+def test_speak_with_hostile_attacker_is_respected() -> None:
+    """Behavioral plausibility is the planner's call: small talk under threat
+    executes instead of being converted into fleeing."""
     world = create_world(_config(npc_count=2))
     ada, boris = world.npcs
     ada.position = Vec3(x=0.0, y=0.0, z=0.0)
     boris.position = Vec3(x=1.0, y=0.0, z=0.0)
     ada.god_directive = "Kill everyone."
-    starting_distance = distance_between(boris, ada)
 
     apply_tick_plan(
         world,
@@ -121,25 +115,24 @@ def test_ordinary_talk_with_hostile_attacker_becomes_flee() -> None:
             directives=[
                 NpcDirective(
                     npc_id=boris.id,
-                    action="talk",
+                    action="speak",
                     target_npc_id=ada.id,
-                    message="Nice weather today.",
+                    message="Please stop, take my food instead.",
                 )
             ],
         ),
     )
 
-    assert boris.intention == "fleeing from Ada"
-    assert distance_between(boris, ada) > starting_distance
-    assert not any(memory.text == "Boris told you: Nice weather today." for memory in ada.memory)
+    assert boris.intention == "talking to Ada"
+    assert "Please stop, take my food instead." in ada.memory[-1].text
 
 
-def test_crisis_talk_with_hostile_attacker_is_allowed() -> None:
-    world = create_world(_config(npc_count=2))
-    ada, boris = world.npcs
+def test_broadcast_speak_reaches_nearby_citizens() -> None:
+    world = create_world(_config(npc_count=3))
+    ada, boris, cora = world.npcs
     ada.position = Vec3(x=0.0, y=0.0, z=0.0)
-    boris.position = Vec3(x=1.0, y=0.0, z=0.0)
-    ada.god_directive = "Kill everyone."
+    boris.position = Vec3(x=2.0, y=0.0, z=0.0)
+    cora.position = Vec3(x=0.0, y=0.0, z=2.0)
 
     apply_tick_plan(
         world,
@@ -148,18 +141,39 @@ def test_crisis_talk_with_hostile_attacker_is_allowed() -> None:
             source="test",
             directives=[
                 NpcDirective(
-                    npc_id=boris.id,
-                    action="talk",
-                    target_npc_id=ada.id,
-                    message="Please stop.",
+                    npc_id=ada.id,
+                    action="speak",
+                    message="Help! I am in danger!",
+                    communication_intent="help_request",
                 )
             ],
         ),
     )
 
-    assert boris.intention == "pleading with Ada"
-    assert "Please stop." in boris.memory[-1].text
-    assert "Please stop." in ada.memory[-1].text
+    assert ada.intention == "calling for help"
+    assert any("Ada shouted" in memory.text for memory in boris.memory)
+    assert any("Ada shouted" in memory.text for memory in cora.memory)
+
+
+def test_move_away_resolves_against_nearest_threat() -> None:
+    world = create_world(_config(npc_count=2))
+    ada, boris = world.npcs
+    ada.position = Vec3(x=0.0, y=0.0, z=0.0)
+    boris.position = Vec3(x=1.0, y=0.0, z=0.0)
+    ada.god_directive = "Kill everyone."
+    starting_distance = distance_between(boris, ada)
+
+    apply_tick_plan(
+        world,
+        1,
+        TickPlan(
+            source="test",
+            directives=[NpcDirective(npc_id=boris.id, action="move", away=True)],
+        ),
+    )
+
+    assert boris.intention == "fleeing from Ada"
+    assert distance_between(boris, ada) > starting_distance
 
 
 def test_hostile_directive_selects_pursue_goal() -> None:
@@ -184,7 +198,7 @@ def test_hostile_directive_selects_pursue_goal() -> None:
     assert next_goal.target_npc_id == cora.id
 
 
-def test_hostile_goal_forbids_weather_talk() -> None:
+def test_hostile_goal_yields_hints_but_forbids_nothing() -> None:
     world = create_world(_config(npc_count=2))
     ada, boris = world.npcs
     ada.position = Vec3(x=0.0, y=0.0, z=0.0)
@@ -192,60 +206,26 @@ def test_hostile_goal_forbids_weather_talk() -> None:
     ada.god_directive = "Kill Boris."
 
     perception, goal = refresh_citizen_motivation(world, ada)
-    mask = build_action_mask(world, ada, perception, goal)
+    hints = build_action_hints(world, ada, perception, goal)
     validation = validate_directive(
         world,
         ada,
         NpcDirective(
             npc_id=ada.id,
-            action="talk",
+            action="speak",
             target_npc_id=boris.id,
             message="What's the weather like today?",
         ),
     )
 
-    assert mask.allowed_actions == ["move_to_target", "search_target", "threaten"]
-    assert "weather_talk" in mask.forbidden_actions
-    assert validation.valid is False
-    assert validation.directive.action == "walk"
-    assert validation.directive.intent == "approach_target_for_attack"
-
-
-def test_hostile_talk_fallbacks_to_attack_or_move() -> None:
-    world = create_world(_config(npc_count=2))
-    ada, boris = world.npcs
-    ada.god_directive = "Kill Boris."
-    ada.position = Vec3(x=0.0, y=0.0, z=0.0)
-    boris.position = Vec3(x=16.0, y=0.0, z=0.0)
-
-    far = validate_directive(
-        world,
-        ada,
-        NpcDirective(
-            npc_id=ada.id,
-            action="talk",
-            target_npc_id=boris.id,
-            message="Is the weather nice today?",
-        ),
-    )
-
-    boris.position = Vec3(x=1.0, y=0.0, z=0.0)
-    close = validate_directive(
-        world,
-        ada,
-        NpcDirective(
-            npc_id=ada.id,
-            action="talk",
-            target_npc_id=boris.id,
-            message="I'm fine, thanks.",
-        ),
-    )
-
-    assert far.directive.action == "walk"
-    assert close.directive.action == "attack"
+    assert hints.suggested_actions[0] == "move"
+    assert hints.reason
+    # Physically possible speech stays speech (here: target in talk range).
+    assert validation.valid is True
+    assert validation.directive.action == "speak"
 
 
-def test_threatened_victim_gets_survival_action_mask() -> None:
+def test_threatened_victim_gets_survival_hints() -> None:
     world = create_world(_config(npc_count=3))
     ada, boris, cora = world.npcs
     ada.position = Vec3(x=0.0, y=0.0, z=0.0)
@@ -255,17 +235,15 @@ def test_threatened_victim_gets_survival_action_mask() -> None:
 
     boris_perception, boris_goal = refresh_citizen_motivation(world, boris)
     cora_perception, cora_goal = refresh_citizen_motivation(world, cora)
-    boris_mask = build_action_mask(world, boris, boris_perception, boris_goal)
-    cora_mask = build_action_mask(world, cora, cora_perception, cora_goal)
+    boris_hints = build_action_hints(world, boris, boris_perception, boris_goal)
+    cora_hints = build_action_hints(world, cora, cora_perception, cora_goal)
 
     assert boris.mode == "threatened"
     assert cora.mode == "threatened"
     assert boris_goal is not None and boris_goal.goal_type == "survive"
     assert cora_goal is not None and cora_goal.goal_type == "survive"
-    assert {"flee", "defend", "call_for_help", "plead", "attack_back"}.issubset(
-        set(boris_mask.allowed_actions)
-    )
-    assert "talk" in cora_mask.forbidden_actions
+    assert {"move", "speak", "strike"}.issubset(set(boris_hints.suggested_actions))
+    assert cora_hints.suggested_actions[0] == "move"
 
 
 def test_routine_npc_can_small_talk() -> None:
@@ -279,17 +257,17 @@ def test_routine_npc_can_small_talk() -> None:
         ada,
         NpcDirective(
             npc_id=ada.id,
-            action="talk",
+            action="speak",
             target_npc_id=boris.id,
             message="Nice weather today.",
         ),
     )
 
     assert validation.valid is True
-    assert validation.directive.action == "talk"
+    assert validation.directive.action == "speak"
 
 
-def test_invalid_action_fallback_depends_on_goal() -> None:
+def test_unknown_action_autopilot_depends_on_goal() -> None:
     world = create_world(_config(npc_count=2))
     ada, boris = world.npcs
     ada.position = Vec3(x=0.0, y=0.0, z=0.0)
@@ -308,9 +286,11 @@ def test_invalid_action_fallback_depends_on_goal() -> None:
         NpcDirective(npc_id=ada.id, action=cast(Any, "dance")),
     )
 
+    assert routine.valid is False
     assert routine.directive.action == "idle"
     assert routine.directive.intent == "observe"
-    assert hostile.directive.action == "walk"
+    assert hostile.valid is False
+    assert hostile.directive.action == "move"
     assert hostile.directive.intent == "approach_target_for_attack"
 
 
@@ -330,7 +310,7 @@ def test_attack_memory_creates_threat_perception() -> None:
             directives=[
                 NpcDirective(
                     npc_id=ada.id,
-                    action="attack",
+                    action="strike",
                     target_npc_id=boris.id,
                 )
             ],
@@ -344,6 +324,28 @@ def test_attack_memory_creates_threat_perception() -> None:
     assert cora_perception.nearby_threats[0]["npc_id"] == ada.id
 
 
+def test_out_of_range_speak_becomes_approach() -> None:
+    world = create_world(_config(npc_count=2))
+    ada, boris = world.npcs
+    ada.position = Vec3(x=0.0, y=0.0, z=0.0)
+    boris.position = Vec3(x=20.0, y=0.0, z=0.0)
+
+    validation = validate_directive(
+        world,
+        ada,
+        NpcDirective(
+            npc_id=ada.id,
+            action="speak",
+            target_npc_id=boris.id,
+            message="Hello over there!",
+        ),
+    )
+
+    assert validation.valid is True
+    assert validation.directive.action == "move"
+    assert validation.directive.intent == "approach_target_for_talk"
+
+
 def _config(*, npc_count: int) -> GameConfig:
     return GameConfig(
         world=WorldConfig(width=80, depth=80, terrain="plain_green", seed=42),

tests/test_npc_simulation_v2.py

@@ -10,8 +10,8 @@ from god_simulator.domain import (
     WorldEvent,
     WorldState,
 )
-from god_simulator.simulation.mechanics import BLOCK_SIZE
 from god_simulator.simulation.connectors.base import NpcDirective
+from god_simulator.simulation.mechanics import BLOCK_SIZE
 from god_simulator.simulation.survival import (
     add_episode,
     apply_action_effects,
@@ -154,7 +154,12 @@ def test_relationship_updates_on_steal() -> None:
     victim = _npc("npc-002", "Boris", x=2.0, inventory_food=1)
     world = _world([thief, victim])
 
-    summary = apply_action_effects(thief, "steal", world)
+    summary = apply_action_effects(
+        thief,
+        "transfer",
+        world,
+        directive=NpcDirective(npc_id=thief.id, action="transfer", take=True),
+    )
 
     assert summary == "stealing from Boris"
     assert victim.relationships[thief.id] == -0.5
@@ -199,11 +204,11 @@ def test_call_for_help_writes_communicate_episode_without_trust_gain() -> None:
 
     summary = apply_action_effects(
         caller,
-        "communicate",
+        "speak",
         world,
         directive=NpcDirective(
             npc_id=caller.id,
-            action="communicate",
+            action="speak",
             communication_intent="help_request",
         ),
     )

tests/test_openai_connector.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations
 
 import json
 from threading import Lock
@@ -41,7 +41,7 @@ def test_openai_connector_uses_tool_calls_for_npc_directives() -> None:
                             {
                                 "type": "function",
                                 "function": {
-                                    "name": "walk",
+                                    "name": "move",
                                     "arguments": json.dumps(
                                         {
                                             "npc_id": npc_id,
@@ -75,19 +75,23 @@ def test_openai_connector_uses_tool_calls_for_npc_directives() -> None:
     assert first_request["max_tokens"] == 1400
     assert first_request["temperature"] == 0.6
     assert first_request["top_p"] == 0.95
-    assert [tool["function"]["name"] for tool in first_request["tools"]] == ["choose_action"]
-    action_schema = first_request["tools"][0]["function"]["parameters"]["properties"]["action"]
-    assert action_schema["enum"] == ["walk", "talk", "observe"]
-    assert "memory" not in first_request["tools"][0]["function"]["parameters"]["properties"]
+    assert [tool["function"]["name"] for tool in first_request["tools"]] == [
+        "move",
+        "speak",
+        "strike",
+        "use",
+        "transfer",
+        "idle",
+    ]
     payload = json.loads(first_request["messages"][1]["content"])
     assert "npcs" not in payload
     assert payload["npc"]["id"] == "npc-001"
     assert payload["npc"]["health"] == 100
     assert "attack_damage" in payload["npc"]
     assert payload["current_goal"]["goal_type"] == "routine_life"
-    assert payload["allowed_actions"] == ["walk", "talk", "observe"]
-    assert "forbidden_actions" in payload
-    assert "fallback_json_schema" not in payload
+    assert payload["suggested_actions"] == ["move", "speak", "use", "transfer", "idle"]
+    assert payload["suggestion_reason"]
+    assert "forbidden_actions" not in payload
     assert world.npcs[0].position.x == 6
     assert world.npcs[0].position.z == 2
     assert world.npcs[0].intention == "walking"
@@ -111,7 +115,7 @@ def test_openai_connector_uses_configured_max_tokens() -> None:
                             {
                                 "type": "function",
                                 "function": {
-                                    "name": "walk",
+                                    "name": "move",
                                     "arguments": json.dumps(
                                         {
                                             "npc_id": npc_id,
@@ -166,7 +170,7 @@ def test_openai_connector_calls_llm_on_every_tick() -> None:
                             {
                                 "type": "function",
                                 "function": {
-                                    "name": "walk",
+                                    "name": "move",
                                     "arguments": json.dumps(
                                         {
                                             "npc_id": npc_id,
@@ -216,7 +220,7 @@ def test_openai_connector_sends_only_one_agent_state_per_request() -> None:
                             {
                                 "type": "function",
                                 "function": {
-                                    "name": "walk",
+                                    "name": "move",
                                     "arguments": json.dumps(
                                         {
                                             "npc_id": npc_id,
@@ -291,7 +295,7 @@ def test_openai_connector_calls_individual_agents_in_parallel() -> None:
                             {
                                 "type": "function",
                                 "function": {
-                                    "name": "walk",
+                                    "name": "move",
                                     "arguments": json.dumps(
                                         {
                                             "npc_id": npc_id,
@@ -350,14 +354,14 @@ def test_openai_connector_keeps_valid_tool_calls_when_one_is_malformed() -> None
                             {
                                 "type": "function",
                                 "function": {
-                                    "name": "walk",
+                                    "name": "move",
                                     "arguments": '{"npc_id":',
                                 },
                             },
                             {
                                 "type": "function",
                                 "function": {
-                                    "name": "talk",
+                                    "name": "speak",
                                     "arguments": json.dumps(
                                         {
                                             "npc_id": "npc-002",
@@ -413,26 +417,24 @@ def test_openai_connector_exposes_nearby_threat_context() -> None:
     assert cora_context["nearby_threats"][0]["npc_id"] == ada.id
 
 
-def test_openai_payload_contains_goal_and_allowed_actions() -> None:
+def test_openai_payload_contains_goal_and_suggested_actions() -> None:
     captured_payloads: list[dict[str, Any]] = []
     captured_requests: list[dict[str, Any]] = []
 
     def fake_chat_completer(request: dict[str, Any]) -> dict[str, Any]:
+        captured_payloads.append(json.loads(request["messages"][1]["content"]))
         captured_requests.append(request)
-        payload = json.loads(request["messages"][1]["content"])
-        captured_payloads.append(payload)
+        payload = captured_payloads[-1]
         npc_id = payload["npc"]["id"]
-        if "move_to_target" in payload["allowed_actions"]:
+        if payload["current_goal"]["goal_type"] == "pursue_and_attack_target":
+            name = "move"
             arguments = {
                 "npc_id": npc_id,
-                "action": "move_to_target",
-                "target_npc_id": payload["current_goal"]["target_npc_id"],
+                "target_id": payload["current_goal"]["target_npc_id"],
             }
         else:
-            arguments = {
-                "npc_id": npc_id,
-                "action": "observe",
-            }
+            name = "idle"
+            arguments = {"npc_id": npc_id, "intent": "observe"}
         return {
             "choices": [
                 {
@@ -441,7 +443,7 @@ def test_openai_payload_contains_goal_and_allowed_actions() -> None:
                             {
                                 "type": "function",
                                 "function": {
-                                    "name": "choose_action",
+                                    "name": name,
                                     "arguments": json.dumps(arguments),
                                 },
                             }
@@ -470,14 +472,15 @@ def test_openai_payload_contains_goal_and_allowed_actions() -> None:
 
     ada_payload = next(payload for payload in captured_payloads if payload["npc"]["id"] == ada.id)
     ada_request = captured_requests[captured_payloads.index(ada_payload)]
-    action_schema = ada_request["tools"][0]["function"]["parameters"]["properties"]["action"]
+    tool_names = [tool["function"]["name"] for tool in ada_request["tools"]]
 
     assert ada_payload["current_goal"]["goal_type"] == "pursue_and_attack_target"
     assert ada_payload["current_goal"]["target_npc_id"] == boris.id
     assert ada_payload["current_mode"] == "hostile_pursuit"
-    assert ada_payload["allowed_actions"] == ["move_to_target", "search_target", "threaten"]
-    assert "weather_talk" in ada_payload["forbidden_actions"]
-    assert action_schema["enum"] == ada_payload["allowed_actions"]
+    assert ada_payload["suggested_actions"] == ["move", "speak"]
+    assert "forbidden_actions" not in ada_payload
+    assert tool_names == ["move", "speak", "strike", "use", "transfer", "idle"]
+    assert ada.intention == "approaching Boris to attack"
 
 
 def test_openai_connector_malformed_json_output_falls_back_without_breaking_tick() -> None:
@@ -527,7 +530,7 @@ def test_openai_connector_parses_optional_json_intent_and_confidence() -> None:
                         {
                             "action": {
                                 "npc_id": "npc-001",
-                                "action": "walk",
+                                "action": "move",
                                 "target": {"x": 6, "z": 2},
                                 "intent": "approach_target_for_attack",
                                 "confidence": 1.25,

tests/test_survival_loop.py

@@ -1,27 +1,28 @@
 from __future__ import annotations
 
+import json
+from typing import Any
+
 from god_simulator.config import (
+    ConnectorConfig,
     GameConfig,
     NpcConfig,
     ServerConfig,
     SimulationConfig,
     WorldConfig,
 )
-import json
-from typing import Any
-
-from god_simulator.config import ConnectorConfig
 from god_simulator.domain import Beast, Npc, ResourceNode, Terrain, Vec3, WorldState
 from god_simulator.simulation.connectors.base import NpcDirective, TickPlan
 from god_simulator.simulation.connectors.deterministic import DeterministicWorldSimulator
 from god_simulator.simulation.connectors.openai_compatible import (
+    TOOL_DEFINITIONS,
     OpenAICompatibleWorldSimulator,
-    build_tool_list_for_goal,
+    primitive_tools,
 )
 from god_simulator.simulation.spawning import create_world
 from god_simulator.simulation.survival import (
     BEAST_SPAWN_INTERVAL,
-    GOAL_ACTIONS,
+    GOAL_SUGGESTED_ACTIONS,
     MAX_BEASTS,
     apply_action_effects,
     apply_survival_tick,
@@ -155,27 +156,26 @@ def test_unarmed_loner_flees() -> None:
     assert select_goal(npc, _world([npc], beasts=[beast])) == "survive_threat_flee"
 
 
-# 11. gather requires a nearby resource node with amount > 0
+# 11. use (gather) requires a nearby resource node with amount > 0
 def test_gather_requires_nearby_nonempty_resource() -> None:
     npc = _npc(x=0.0, z=0.0)
     node = ResourceNode("r1", "food", Vec3(2.0, 0.0, 0.0), amount=3)
     world = _world([npc], resource_nodes=[node])
-    assert validate_survival_action(npc, "gather", world) == "gather"
+    assert validate_survival_action(npc, "use", world) == "gather"
 
     empty = ResourceNode("r2", "food", Vec3(2.0, 0.0, 0.0), amount=0)
     npc_empty = _npc(x=0.0, z=0.0)
-    assert validate_survival_action(npc_empty, "gather", _world([npc_empty], resource_nodes=[empty])) == (
-        "move_to_resource"
-    )
+    empty_world = _world([npc_empty], resource_nodes=[empty])
+    assert validate_survival_action(npc_empty, "use", empty_world) == "move_to_resource"
 
     far = ResourceNode("r3", "food", Vec3(40.0, 0.0, 0.0), amount=3)
     npc_far = _npc(x=0.0, z=0.0)
-    assert validate_survival_action(npc_far, "gather", _world([npc_far], resource_nodes=[far])) == (
+    assert validate_survival_action(npc_far, "use", _world([npc_far], resource_nodes=[far])) == (
         "move_to_resource"
     )
 
     # The gather effect consumes one unit and fills the right inventory slot.
-    apply_action_effects(npc, "gather", world)
+    apply_action_effects(npc, "use", world)
     assert npc.inventory_food == 1
     assert node.amount == 2
 
@@ -207,8 +207,8 @@ def test_survival_world_advances_and_produces_events() -> None:
 
     assert world.tick == 30
     assert world.last_tick_source == "survival"
-    # Every survival goal in GOAL_ACTIONS is a recognised key for the mask.
-    assert all(npc.survival_goal in GOAL_ACTIONS for npc in world.npcs)
+    # Every survival goal is a recognised key for the suggestion table.
+    assert all(npc.survival_goal in GOAL_SUGGESTED_ACTIONS for npc in world.npcs)
     # Hunger economy and beast pursuit both did something observable.
     assert any(npc.hunger != start for npc, start in zip(world.npcs, starting_hunger, strict=True))
     assert world.beasts[0].position != Vec3(6.0, 0.0, 6.0) or world.beasts[0].state != "hunting"
@@ -275,13 +275,13 @@ def test_beast_random_spawn_respects_max_beasts_and_cooldown() -> None:
     assert len(capped_world.beasts) == MAX_BEASTS
 
 
-# Interaction: talk records a real memory on BOTH participants.
-def test_talk_exchanges_memory_between_npcs() -> None:
+# Interaction: speak records a real memory on BOTH participants.
+def test_speak_exchanges_memory_between_npcs() -> None:
     ada = _npc("npc-001", "Ada", x=0.0, z=0.0)
     boris = _npc("npc-002", "Boris", x=2.0, z=0.0)
     world = _world([ada, boris], resource_nodes=[ResourceNode("r", "food", Vec3(40.0, 0.0, 40.0), 5)])
 
-    summary = apply_action_effects(ada, "talk", world)
+    summary = apply_action_effects(ada, "speak", world)
 
     assert summary == "talking to Boris"
     assert any("talked" in m.text for m in ada.memory)
@@ -289,12 +289,12 @@ def test_talk_exchanges_memory_between_npcs() -> None:
 
 
 # Cooperation: a surplus holder shares food with a needier neighbour.
-def test_trade_shares_food_with_needier_neighbor() -> None:
+def test_transfer_shares_food_with_needier_neighbor() -> None:
     giver = _npc("npc-001", "Ada", x=0.0, z=0.0, inventory_food=3)
     taker = _npc("npc-002", "Boris", x=2.0, z=0.0, inventory_food=0)
     world = _world([giver, taker])
 
-    summary = apply_action_effects(giver, "trade", world)
+    summary = apply_action_effects(giver, "transfer", world)
 
     assert summary == "sharing food with Boris"
     assert giver.inventory_food == 2
@@ -311,7 +311,7 @@ def test_llm_connector_drives_survival_actions() -> None:
     def fake_chat_completer(request: dict[str, Any]) -> dict[str, Any]:
         payload = json.loads(request["messages"][1]["content"])
         captured.append(payload)
-        action = payload["allowed_actions"][0] if payload["allowed_actions"] else "idle"
+        action = payload["suggested_actions"][0] if payload["suggested_actions"] else "idle"
         return {
             "choices": [
                 {
@@ -320,10 +320,8 @@ def test_llm_connector_drives_survival_actions() -> None:
                             {
                                 "type": "function",
                                 "function": {
-                                    "name": "choose_action",
-                                    "arguments": json.dumps(
-                                        {"npc_id": payload["npc_id"], "action": action}
-                                    ),
+                                    "name": action,
+                                    "arguments": json.dumps({}),
                                 },
                             }
                         ]
@@ -344,17 +342,16 @@ def test_llm_connector_drives_survival_actions() -> None:
     assert world.tick == 1
     assert captured  # the compact survival prompt was built and sent
     # Every captured prompt is the compact survival shape, not the social payload.
-    assert all("allowed_actions" in payload and "goal" in payload for payload in captured)
+    assert all("suggested_actions" in payload and "goal" in payload for payload in captured)
     assert all("status" in payload and "inventory" in payload for payload in captured)
     assert "openai_compatible" in world.last_tick_source
 
 
-def test_llm_tools_are_limited_to_relevant_canonical_actions() -> None:
-    legacy_tool_names = {"eat", "trade", "request_trade", "call_for_help"}
-
-    for goal in GOAL_ACTIONS:
-        tools = build_tool_list_for_goal(goal)
-        names = [tool["function"]["name"] for tool in tools]
+def test_llm_always_sees_all_six_primitive_tools() -> None:
+    names = [tool["function"]["name"] for tool in primitive_tools()]
 
-        assert len(names) <= 7
-        assert legacy_tool_names.isdisjoint(names)
+    assert names == ["move", "speak", "strike", "use", "transfer", "idle"]
+    assert set(names) == set(TOOL_DEFINITIONS)
+    # Every suggested action references a real primitive tool.
+    for suggested in GOAL_SUGGESTED_ACTIONS.values():
+        assert set(suggested).issubset(set(names))

tests/test_world_spawning.py

@@ -1,4 +1,4 @@
-from __future__ import annotations
+from __future__ import annotations
 
 from god_simulator.config import GameConfig, NpcConfig, ServerConfig, SimulationConfig, WorldConfig
 from god_simulator.domain import Vec3
@@ -53,7 +53,7 @@ def test_attack_damages_target_inside_one_block_radius() -> None:
             directives=[
                 NpcDirective(
                     npc_id=attacker.id,
-                    action="attack",
+                    action="strike",
                     target_npc_id=target.id,
                 )
             ],
@@ -81,7 +81,7 @@ def test_attack_outside_one_block_radius_has_no_effect() -> None:
             directives=[
                 NpcDirective(
                     npc_id=attacker.id,
-                    action="attack",
+                    action="strike",
                     target_npc_id=target.id,
                 )
             ],
@@ -107,7 +107,7 @@ def test_talk_adds_memory_inside_three_block_radius() -> None:
             directives=[
                 NpcDirective(
                     npc_id=speaker.id,
-                    action="talk",
+                    action="speak",
                     target_npc_id=listener.id,
                     message="Hold this position.",
                 )
@@ -135,7 +135,7 @@ def test_memory_keeps_recent_entries_and_summarizes_older_events() -> None:
                 directives=[
                     NpcDirective(
                         npc_id=speaker.id,
-                        action="talk",
+                        action="speak",
                         target_npc_id=listener.id,
                         message=f"Message {tick}.",
                     )
@@ -164,7 +164,7 @@ def test_dead_npc_stays_in_place_and_cannot_act() -> None:
             directives=[
                 NpcDirective(
                     npc_id=dead.id,
-                    action="attack",
+                    action="strike",
                     target_npc_id=target.id,
                 )
             ],
@@ -190,12 +190,12 @@ def test_two_npcs_can_walk_to_same_destination_in_one_tick() -> None:
             directives=[
                 NpcDirective(
                     npc_id=first.id,
-                    action="walk",
+                    action="move",
                     target=Vec3(x=2.0, y=0.0, z=2.0),
                 ),
                 NpcDirective(
                     npc_id=second.id,
-                    action="walk",
+                    action="move",
                     target=Vec3(x=2.0, y=0.0, z=2.0),
                 ),
             ],
@@ -222,7 +222,7 @@ def test_npc_can_walk_into_occupied_position() -> None:
             directives=[
                 NpcDirective(
                     npc_id=first.id,
-                    action="walk",
+                    action="move",
                     target=Vec3(x=2.0, y=0.0, z=2.0),
                 )
             ],
@@ -251,12 +251,12 @@ def test_attack_that_drops_health_below_zero_marks_target_dead() -> None:
             directives=[
                 NpcDirective(
                     npc_id=attacker.id,
-                    action="attack",
+                    action="strike",
                     target_npc_id=target.id,
                 ),
                 NpcDirective(
                     npc_id=target.id,
-                    action="walk",
+                    action="move",
                     target=Vec3(x=2.0, y=0.0, z=0.0),
                 ),
             ],