feat: add physical animal care delivery

tests/animal_feeding_vertical_slice_test.gd

@@ -18,6 +18,7 @@ func _run() -> void:
 
 	var goat := main_scene.get_node("JajceWorld/WorldObjects/Animals/Dunja") as AnimalNode
 	var player := main_scene.get_node("Player") as Node3D
+	var pantry_node := StorageNode.get_by_id(SimulationIds.STORAGE_VILLAGE_PANTRY) as StorageNode
 	var pantry: StorageStateRecord = manager.get_pantry()
 	var state: AnimalStateRecord = manager.animal_care.get_state(SimulationIds.ANIMAL_DUNJA)
 	_check(goat != null, "Jajce should load Dunja's named presentation")
@@ -81,9 +82,23 @@ func _run() -> void:
 		(
 			caretaker.target_id == SimulationIds.ANIMAL_DUNJA
 			and state.get_reserved_by() == caretaker.id
+			and pantry_node != null
+			and caretaker.travel_target_position.is_equal_approx(
+				pantry_node.get_interaction_position()
+			)
+		),
+		"Animal target resolution should retain Dunja's exact claim while routing to the pantry"
+	)
+	manager.notify_npc_arrived(caretaker.id)
+	_check(
+		(
+			is_equal_approx(caretaker.get_inventory_amount(SimulationIds.RESOURCE_FOOD), 1.0)
+			and caretaker.target_id == SimulationIds.ANIMAL_DUNJA
+			and state.get_reserved_by() == caretaker.id
+			and caretaker.task_state == SimNPC.TASK_STATE_TRAVELING
 			and caretaker.travel_target_position.is_equal_approx(goat.get_interaction_position())
 		),
-		"Animal target resolution should claim Dunja's loaded interaction point by stable ID"
+		"Pantry arrival should carry one real food toward the same reserved Dunja",
 	)
 	manager.notify_npc_arrived(caretaker.id)
 	manager.simulate_tick()
@@ -115,14 +130,15 @@ func _run() -> void:
 			npc_feed_event != null
 			and int(npc_feed_event.data["actor_id"]) == caretaker.id
 			and (
-				StringName(npc_feed_event.data["source_id"]) == SimulationIds.STORAGE_VILLAGE_PANTRY
+				StringName(npc_feed_event.data["source_id"])
+				== SimulationIds.npc_inventory_id(caretaker.id)
 			)
 			and (StringName(npc_feed_event.data["destination_id"]) == SimulationIds.ANIMAL_DUNJA)
 			and StringName(npc_feed_event.data["item_id"]) == SimulationIds.RESOURCE_FOOD
 			and is_equal_approx(float(npc_feed_event.data["amount"]), 1.0)
 			and npc_feed_event.get_world_position().is_equal_approx(state.get_position())
 		),
-		"NPC feeding should record one exact pantry-to-animal transfer fact"
+		"NPC feeding should record one exact carried-inventory-to-animal transfer fact"
 	)
 	_check(
 		(
@@ -172,7 +188,7 @@ func _run() -> void:
 			and int(player_feed_event.data["actor_id"]) == -1
 			and (StringName(player_feed_event.data["destination_id"]) == SimulationIds.ANIMAL_DUNJA)
 		),
-		"The player should use the same one-food feed operation and event contract"
+		"The player should use the same exact one-food animal mutation"
 	)
 	var player_feed_json: String = manager.serialize_state()
 	_check(

tests/animal_food_delivery_test.gd

@@ -0,0 +1,864 @@
+extends SceneTree
+
+var failures: Array[String] = []
+
+
+func _initialize() -> void:
+	call_deferred("_run")
+
+
+func _run() -> void:
+	await _test_single_two_leg_delivery()
+	await _test_one_unit_contention()
+	await _test_legacy_pre_pickup_restore_reroutes()
+	await _test_legacy_working_restore_reroutes()
+	await _test_post_pickup_restore_continuation()
+	_finish()
+
+
+func _test_single_two_leg_delivery() -> void:
+	var fixture := await _load_world()
+	var main_scene: Node = fixture["main"]
+	var manager: Node = fixture["manager"]
+	var view: Node = fixture["view"]
+	var pantry_node := StorageNode.get_by_id(SimulationIds.STORAGE_VILLAGE_PANTRY) as StorageNode
+	var zora_node := AnimalNode.get_by_id(SimulationIds.ANIMAL_ZORA)
+	var dunja_node := AnimalNode.get_by_id(SimulationIds.ANIMAL_DUNJA)
+	var pantry: StorageStateRecord = manager.get_pantry()
+	var zora_state: AnimalStateRecord = manager.animal_care.get_state(SimulationIds.ANIMAL_ZORA)
+	var dunja_state: AnimalStateRecord = manager.animal_care.get_state(SimulationIds.ANIMAL_DUNJA)
+	_check(
+		(
+			pantry_node != null
+			and zora_node != null
+			and dunja_node != null
+			and pantry != null
+			and zora_state != null
+			and dunja_state != null
+		),
+		"The delivery proof needs the authored pantry and both bound named goats",
+	)
+	if (
+		pantry_node == null
+		or zora_node == null
+		or dunja_node == null
+		or pantry == null
+		or zora_state == null
+		or dunja_state == null
+	):
+		await _unload_world(main_scene)
+		return
+
+	_prepare_population(manager, view)
+	_set_pantry_food(manager, 3.0)
+	zora_state.set_hunger(72.0)
+	dunja_state.set_hunger(30.0)
+	var caretaker: SimNPC = manager.npcs[0]
+	var origin := zora_node.get_interaction_position()
+	_prepare_feed_task(manager, view, caretaker, origin)
+
+	_check(
+		manager.resolve_npc_target(caretaker.id, origin),
+		"A caretaker should resolve a physical route for hungry Zora",
+	)
+	_check(
+		(
+			caretaker.current_task == SimulationIds.ACTION_FEED_ANIMAL
+			and caretaker.target_id == SimulationIds.ANIMAL_ZORA
+			and zora_state.get_reserved_by() == caretaker.id
+			and caretaker.has_travel_target
+			and caretaker.travel_target_position.is_equal_approx(
+				pantry_node.get_interaction_position()
+			)
+		),
+		"The first feed leg should retain exact Zora authority while targeting the pantry",
+	)
+
+	var pantry_before := pantry.get_amount(SimulationIds.RESOURCE_FOOD)
+	var observed_villages := []
+	var observed_food := []
+	var observed_states := []
+	manager.village_changed.connect(
+		func(changed_village):
+			observed_villages.append(changed_village)
+			observed_food.append(changed_village.food)
+			observed_states.append(manager.serialize_state())
+	)
+	_arrive_at_current_target(manager, view, caretaker)
+	var withdrawal_events := _events_for(
+		manager, SimulationIds.EVENT_STORAGE_WITHDRAWN, caretaker.id
+	)
+	var observed_record: SimulationStateRecord
+	var observed_npc: SimNPC
+	if observed_states.size() == 1:
+		observed_record = SimulationStateRecord.from_json(String(observed_states[0]))
+		if observed_record != null:
+			var observed_npc_record := _find_npc_record(observed_record.npcs, caretaker.id)
+			if observed_npc_record != null:
+				observed_npc = observed_npc_record.restore(false)
+	_check(
+		(
+			is_equal_approx(pantry.get_amount(SimulationIds.RESOURCE_FOOD), pantry_before - 1.0)
+			and is_equal_approx(caretaker.get_inventory_amount(SimulationIds.RESOURCE_FOOD), 1.0)
+			and caretaker.current_task == SimulationIds.ACTION_FEED_ANIMAL
+			and caretaker.task_state == SimNPC.TASK_STATE_TRAVELING
+			and caretaker.target_id == SimulationIds.ANIMAL_ZORA
+			and zora_state.get_reserved_by() == caretaker.id
+			and caretaker.has_travel_target
+			and caretaker.travel_target_position.is_equal_approx(
+				zora_node.get_interaction_position()
+			)
+			and observed_villages.size() == 1
+			and observed_villages[0] == manager.village
+			and is_equal_approx(float(observed_food[0]), pantry_before - 1.0)
+			and observed_record != null
+			and observed_npc != null
+			and is_equal_approx(observed_npc.get_inventory_amount(SimulationIds.RESOURCE_FOOD), 1.0)
+			and observed_npc.target_id == SimulationIds.ANIMAL_ZORA
+			and observed_npc.travel_target_position.is_equal_approx(
+				zora_node.get_interaction_position()
+			)
+		),
+		(
+			"Pantry arrival should atomically expose synchronized food, carried inventory, "
+			+ "and the same claimed Zora delivery waypoint"
+		),
+	)
+	_check(
+		(
+			withdrawal_events.size() == 1
+			and _is_exact_withdrawal(
+				withdrawal_events[0],
+				caretaker.id,
+				pantry_node.get_interaction_position(),
+			)
+		),
+		"The pickup leg should record one exact pantry-to-caretaker transfer at the pantry",
+	)
+	var carried_food := _get_carried_food(view, caretaker.id)
+	_check(
+		carried_food != null and carried_food.visible,
+		"Authoritative caretaker inventory should reveal the existing carried-food prop",
+	)
+	_check(
+		is_equal_approx(
+			(
+				pantry.get_amount(SimulationIds.RESOURCE_FOOD)
+				+ caretaker.get_inventory_amount(SimulationIds.RESOURCE_FOOD)
+			),
+			pantry_before,
+		),
+		"Food should be conserved across the pantry pickup boundary",
+	)
+
+	var zora_hunger_before := zora_state.get_hunger()
+	var dunja_hunger_before := dunja_state.get_hunger()
+	_arrive_at_current_target(manager, view, caretaker)
+	_check(
+		caretaker.task_state == SimNPC.TASK_STATE_WORKING,
+		"Arrival at exact Zora should begin the feed work without another withdrawal",
+	)
+	var work_ticks := int(ceil(caretaker.task_duration))
+	for _tick in range(work_ticks):
+		manager.simulate_tick()
+
+	var feed_events := _events_for(manager, SimulationIds.EVENT_ANIMAL_FED, caretaker.id)
+	_check(
+		(
+			is_equal_approx(
+				zora_state.get_hunger(),
+				(
+					zora_hunger_before
+					+ AnimalStateRecord.HUNGER_PER_TICK * work_ticks
+					- AnimalStateRecord.HUNGER_RELIEF
+				),
+			)
+			and is_equal_approx(
+				dunja_state.get_hunger(),
+				dunja_hunger_before + AnimalStateRecord.HUNGER_PER_TICK * work_ticks,
+			)
+			and zora_state.get_last_fed_tick() == manager.tick_count
+			and zora_state.get_reserved_by() == -1
+			and is_equal_approx(pantry.get_amount(SimulationIds.RESOURCE_FOOD), pantry_before - 1.0)
+			and is_equal_approx(caretaker.get_inventory_amount(SimulationIds.RESOURCE_FOOD), 0.0)
+		),
+		"Delivery completion should consume carried food and mutate only Zora beyond natural hunger",
+	)
+	_check(
+		(
+			feed_events.size() == 1
+			and _is_exact_feed(feed_events[0], caretaker.id, SimulationIds.ANIMAL_ZORA, zora_state)
+			and (
+				_events_for(manager, SimulationIds.EVENT_STORAGE_WITHDRAWN, caretaker.id).size()
+				== 1
+			)
+		),
+		"The complete delivery should retain one withdrawal followed by one exact inventory feed",
+	)
+	_check(
+		(
+			feed_events.size() == 1
+			and is_equal_approx(
+				(
+					pantry.get_amount(SimulationIds.RESOURCE_FOOD)
+					+ caretaker.get_inventory_amount(SimulationIds.RESOURCE_FOOD)
+					+ float(feed_events[0].data["amount"])
+				),
+				pantry_before,
+			)
+		),
+		"Exactly one delivered food should account for the unit that leaves tracked holdings",
+	)
+	carried_food = _get_carried_food(view, caretaker.id)
+	_check(
+		carried_food != null and not carried_food.visible,
+		"The carried-food prop should disappear after the exact goat receives it",
+	)
+
+	await _unload_world(main_scene)
+
+
+func _test_one_unit_contention() -> void:
+	var fixture := await _load_world()
+	var main_scene: Node = fixture["main"]
+	var manager: Node = fixture["manager"]
+	var view: Node = fixture["view"]
+	var pantry_node := StorageNode.get_by_id(SimulationIds.STORAGE_VILLAGE_PANTRY) as StorageNode
+	var zora_node := AnimalNode.get_by_id(SimulationIds.ANIMAL_ZORA)
+	var dunja_node := AnimalNode.get_by_id(SimulationIds.ANIMAL_DUNJA)
+	var pantry: StorageStateRecord = manager.get_pantry()
+	var zora_state: AnimalStateRecord = manager.animal_care.get_state(SimulationIds.ANIMAL_ZORA)
+	var dunja_state: AnimalStateRecord = manager.animal_care.get_state(SimulationIds.ANIMAL_DUNJA)
+	if (
+		pantry_node == null
+		or zora_node == null
+		or dunja_node == null
+		or pantry == null
+		or zora_state == null
+		or dunja_state == null
+	):
+		_check(false, "The contention proof needs the authored pantry and paired goats")
+		await _unload_world(main_scene)
+		return
+
+	_prepare_population(manager, view)
+	_set_pantry_food(manager, 1.0)
+	zora_state.set_hunger(72.0)
+	dunja_state.set_hunger(72.0)
+	var winner: SimNPC = manager.npcs[0]
+	var loser: SimNPC = manager.npcs[1]
+	var shared_origin := zora_node.get_interaction_position()
+	_prepare_feed_task(manager, view, winner, shared_origin)
+	_prepare_feed_task(manager, view, loser, shared_origin)
+	var winner_resolved: bool = manager.resolve_npc_target(winner.id, shared_origin)
+	var loser_resolved: bool = manager.resolve_npc_target(loser.id, shared_origin)
+	_check(
+		(
+			winner_resolved
+			and loser_resolved
+			and winner.target_id == SimulationIds.ANIMAL_ZORA
+			and loser.target_id == SimulationIds.ANIMAL_DUNJA
+			and zora_state.get_reserved_by() == winner.id
+			and dunja_state.get_reserved_by() == loser.id
+			and winner.travel_target_position.is_equal_approx(
+				pantry_node.get_interaction_position()
+			)
+			and loser.travel_target_position.is_equal_approx(pantry_node.get_interaction_position())
+		),
+		"Two caretakers should retain independent exact goat claims while sharing the pantry leg",
+	)
+
+	_arrive_at_current_target(manager, view, winner)
+	_arrive_at_current_target(manager, view, loser)
+	var all_withdrawals := _events_of_type(manager, SimulationIds.EVENT_STORAGE_WITHDRAWN)
+	var loser_blocked := _events_for(manager, SimulationIds.EVENT_TASK_BLOCKED, loser.id)
+	_check(
+		(
+			is_equal_approx(pantry.get_amount(SimulationIds.RESOURCE_FOOD), 0.0)
+			and is_equal_approx(winner.get_inventory_amount(SimulationIds.RESOURCE_FOOD), 1.0)
+			and is_equal_approx(loser.get_inventory_amount(SimulationIds.RESOURCE_FOOD), 0.0)
+			and all_withdrawals.size() == 1
+			and int(all_withdrawals[0].data["actor_id"]) == winner.id
+		),
+		"One pantry unit should produce exactly one winning pickup without duplication",
+	)
+	_check(
+		(
+			winner.current_task == SimulationIds.ACTION_FEED_ANIMAL
+			and winner.target_id == SimulationIds.ANIMAL_ZORA
+			and zora_state.get_reserved_by() == winner.id
+			and loser.current_task != SimulationIds.ACTION_FEED_ANIMAL
+			and loser.get_inventory_amount(SimulationIds.RESOURCE_FOOD) == 0.0
+			and dunja_state.get_reserved_by() == -1
+			and loser_blocked.size() == 1
+			and (
+				StringName(loser_blocked[0].data["source_id"])
+				== SimulationIds.STORAGE_VILLAGE_PANTRY
+			)
+			and (StringName(loser_blocked[0].data["action_id"]) == SimulationIds.ACTION_FEED_ANIMAL)
+			and is_equal_approx(float(loser_blocked[0].data["required_amount"]), 1.0)
+		),
+		"The losing pantry arrival should record the shortfall, release only its claim, and not feed",
+	)
+
+	var zora_hunger_before := zora_state.get_hunger()
+	var dunja_hunger_before := dunja_state.get_hunger()
+	_arrive_at_current_target(manager, view, winner)
+	var work_ticks := int(ceil(winner.task_duration))
+	for _tick in range(work_ticks):
+		manager.simulate_tick()
+	var feed_events := _events_of_type(manager, SimulationIds.EVENT_ANIMAL_FED)
+	_check(
+		(
+			feed_events.size() == 1
+			and _is_exact_feed(feed_events[0], winner.id, SimulationIds.ANIMAL_ZORA, zora_state)
+			and is_equal_approx(
+				zora_state.get_hunger(),
+				(
+					zora_hunger_before
+					+ AnimalStateRecord.HUNGER_PER_TICK * work_ticks
+					- AnimalStateRecord.HUNGER_RELIEF
+				),
+			)
+			and is_equal_approx(
+				dunja_state.get_hunger(),
+				dunja_hunger_before + AnimalStateRecord.HUNGER_PER_TICK * work_ticks,
+			)
+		),
+		"Contention should complete only the winning caretaker's exact Zora delivery",
+	)
+	_check(
+		(
+			_events_of_type(manager, SimulationIds.EVENT_STORAGE_WITHDRAWN).size() == 1
+			and is_equal_approx(
+				(
+					pantry.get_amount(SimulationIds.RESOURCE_FOOD)
+					+ winner.get_inventory_amount(SimulationIds.RESOURCE_FOOD)
+					+ loser.get_inventory_amount(SimulationIds.RESOURCE_FOOD)
+					+ float(feed_events[0].data["amount"])
+				),
+				1.0,
+			)
+		),
+		"One-unit contention should conserve exactly one food through final delivery",
+	)
+
+	await _unload_world(main_scene)
+
+
+func _test_legacy_pre_pickup_restore_reroutes() -> void:
+	var fixture := await _load_world()
+	var main_scene: Node = fixture["main"]
+	var manager: Node = fixture["manager"]
+	var view: Node = fixture["view"]
+	var pantry_node := StorageNode.get_by_id(SimulationIds.STORAGE_VILLAGE_PANTRY) as StorageNode
+	var zora_node := AnimalNode.get_by_id(SimulationIds.ANIMAL_ZORA)
+	var pantry: StorageStateRecord = manager.get_pantry()
+	var zora_state: AnimalStateRecord = manager.animal_care.get_state(SimulationIds.ANIMAL_ZORA)
+	if pantry_node == null or zora_node == null or pantry == null or zora_state == null:
+		_check(false, "The legacy-route proof needs the authored pantry and Zora")
+		await _unload_world(main_scene)
+		return
+
+	_prepare_population(manager, view)
+	_set_pantry_food(manager, 2.0)
+	zora_state.set_hunger(72.0)
+	var caretaker: SimNPC = manager.npcs[0]
+	var caretaker_id := caretaker.id
+	var origin := zora_node.get_interaction_position()
+	_prepare_feed_task(manager, view, caretaker, origin)
+	_check(
+		manager.resolve_npc_target(caretaker.id, origin),
+		"The legacy-route caretaker should establish an exact Zora claim",
+	)
+
+	# Schema v11 predates the pantry leg, so its valid active feed records can
+	# retain an empty inventory while traveling directly to the claimed goat.
+	caretaker.travel_target_position = zora_node.get_interaction_position()
+	caretaker.has_travel_target = true
+	var legacy_route_json: String = manager.serialize_state()
+	var legacy_route_checksum: String = manager.get_state_checksum()
+	var pantry_before := pantry.get_amount(SimulationIds.RESOURCE_FOOD)
+	_check(
+		manager.restore_state_from_json(legacy_route_json),
+		"A pre-delivery schema-v11 feed route should remain restorable",
+	)
+	_freeze_visuals(view)
+	caretaker = _find_npc(manager.npcs, caretaker_id)
+	pantry = manager.get_pantry()
+	zora_state = manager.animal_care.get_state(SimulationIds.ANIMAL_ZORA)
+	_check(
+		(
+			caretaker != null
+			and manager.get_state_checksum() == legacy_route_checksum
+			and caretaker.travel_target_position.is_equal_approx(
+				zora_node.get_interaction_position()
+			)
+			and is_equal_approx(caretaker.get_inventory_amount(SimulationIds.RESOURCE_FOOD), 0.0)
+			and zora_state.get_reserved_by() == caretaker_id
+		),
+		"Restore should first preserve the valid legacy route and exact claim",
+	)
+	if caretaker == null:
+		await _unload_world(main_scene)
+		return
+
+	_arrive_at_current_target(manager, view, caretaker)
+	_check(
+		(
+			is_equal_approx(pantry.get_amount(SimulationIds.RESOURCE_FOOD), pantry_before)
+			and is_equal_approx(caretaker.get_inventory_amount(SimulationIds.RESOURCE_FOOD), 0.0)
+			and _events_for(manager, SimulationIds.EVENT_STORAGE_WITHDRAWN, caretaker_id).is_empty()
+			and caretaker.current_task == SimulationIds.ACTION_FEED_ANIMAL
+			and caretaker.task_state == SimNPC.TASK_STATE_TRAVELING
+			and caretaker.target_id == SimulationIds.ANIMAL_ZORA
+			and zora_state.get_reserved_by() == caretaker_id
+			and caretaker.travel_target_position.is_equal_approx(
+				pantry_node.get_interaction_position()
+			)
+		),
+		"Legacy goat arrival should reroute to the pantry without a remote withdrawal",
+	)
+
+	_arrive_at_current_target(manager, view, caretaker)
+	var withdrawal_events := _events_for(
+		manager, SimulationIds.EVENT_STORAGE_WITHDRAWN, caretaker_id
+	)
+	_check(
+		(
+			is_equal_approx(pantry.get_amount(SimulationIds.RESOURCE_FOOD), pantry_before - 1.0)
+			and is_equal_approx(caretaker.get_inventory_amount(SimulationIds.RESOURCE_FOOD), 1.0)
+			and withdrawal_events.size() == 1
+			and _is_exact_withdrawal(
+				withdrawal_events[0],
+				caretaker_id,
+				pantry_node.get_interaction_position(),
+			)
+			and caretaker.travel_target_position.is_equal_approx(
+				zora_node.get_interaction_position()
+			)
+			and zora_state.get_reserved_by() == caretaker_id
+		),
+		"Legacy continuation should withdraw only after physical pantry arrival",
+	)
+
+	await _unload_world(main_scene)
+
+
+func _test_legacy_working_restore_reroutes() -> void:
+	var fixture := await _load_world()
+	var main_scene: Node = fixture["main"]
+	var manager: Node = fixture["manager"]
+	var view: Node = fixture["view"]
+	var pantry_node := StorageNode.get_by_id(SimulationIds.STORAGE_VILLAGE_PANTRY) as StorageNode
+	var zora_node := AnimalNode.get_by_id(SimulationIds.ANIMAL_ZORA)
+	var pantry: StorageStateRecord = manager.get_pantry()
+	var zora_state: AnimalStateRecord = manager.animal_care.get_state(SimulationIds.ANIMAL_ZORA)
+	if pantry_node == null or zora_node == null or pantry == null or zora_state == null:
+		_check(false, "The legacy-working proof needs the authored pantry and Zora")
+		await _unload_world(main_scene)
+		return
+
+	_prepare_population(manager, view)
+	_set_pantry_food(manager, 2.0)
+	zora_state.set_hunger(72.0)
+	var caretaker: SimNPC = manager.npcs[0]
+	var caretaker_id := caretaker.id
+	var origin := zora_node.get_interaction_position()
+	_prepare_feed_task(manager, view, caretaker, origin)
+	_check(
+		manager.resolve_npc_target(caretaker.id, origin),
+		"The legacy-working caretaker should establish an exact Zora claim",
+	)
+
+	# The old one-leg flow could also be saved after goat arrival, while work
+	# was already in progress but before pantry-backed completion.
+	caretaker.task_state = SimNPC.TASK_STATE_WORKING
+	caretaker.task_progress = 2.0
+	caretaker.task_complete = false
+	caretaker.has_travel_target = false
+	caretaker.travel_target_position = zora_node.get_interaction_position()
+	var legacy_working_json: String = manager.serialize_state()
+	var legacy_working_checksum: String = manager.get_state_checksum()
+	var pantry_before := pantry.get_amount(SimulationIds.RESOURCE_FOOD)
+	_check(
+		manager.restore_state_from_json(legacy_working_json),
+		"A working pre-delivery schema-v11 feed state should remain restorable",
+	)
+	_freeze_visuals(view)
+	caretaker = _find_npc(manager.npcs, caretaker_id)
+	pantry = manager.get_pantry()
+	zora_state = manager.animal_care.get_state(SimulationIds.ANIMAL_ZORA)
+	_check(
+		(
+			caretaker != null
+			and manager.get_state_checksum() == legacy_working_checksum
+			and caretaker.task_state == SimNPC.TASK_STATE_WORKING
+			and is_equal_approx(caretaker.task_progress, 2.0)
+			and is_equal_approx(caretaker.get_inventory_amount(SimulationIds.RESOURCE_FOOD), 0.0)
+			and zora_state.get_reserved_by() == caretaker_id
+		),
+		"Restore should initially preserve the legacy working state and checksum",
+	)
+	if caretaker == null:
+		await _unload_world(main_scene)
+		return
+
+	manager.simulate_tick()
+	_check(
+		(
+			is_equal_approx(pantry.get_amount(SimulationIds.RESOURCE_FOOD), pantry_before)
+			and is_equal_approx(caretaker.get_inventory_amount(SimulationIds.RESOURCE_FOOD), 0.0)
+			and _events_for(manager, SimulationIds.EVENT_STORAGE_WITHDRAWN, caretaker_id).is_empty()
+			and caretaker.current_task == SimulationIds.ACTION_FEED_ANIMAL
+			and caretaker.task_state == SimNPC.TASK_STATE_TRAVELING
+			and caretaker.target_id == SimulationIds.ANIMAL_ZORA
+			and caretaker.has_travel_target
+			and caretaker.travel_target_position.is_equal_approx(
+				pantry_node.get_interaction_position()
+			)
+			and is_equal_approx(caretaker.task_progress, 2.0)
+			and zora_state.get_reserved_by() == caretaker_id
+		),
+		"The first resumed tick should preserve work progress and reroute to the pantry",
+	)
+
+	_arrive_at_current_target(manager, view, caretaker)
+	_check(
+		(
+			is_equal_approx(pantry.get_amount(SimulationIds.RESOURCE_FOOD), pantry_before - 1.0)
+			and is_equal_approx(caretaker.get_inventory_amount(SimulationIds.RESOURCE_FOOD), 1.0)
+			and caretaker.task_state == SimNPC.TASK_STATE_TRAVELING
+			and caretaker.travel_target_position.is_equal_approx(
+				zora_node.get_interaction_position()
+			)
+			and is_equal_approx(caretaker.task_progress, 2.0)
+			and zora_state.get_reserved_by() == caretaker_id
+		),
+		"Recovered work should pick up at the pantry and return to the same Zora claim",
+	)
+	_arrive_at_current_target(manager, view, caretaker)
+	_check(
+		(
+			caretaker.task_state == SimNPC.TASK_STATE_WORKING
+			and is_equal_approx(caretaker.task_progress, 2.0)
+			and is_equal_approx(caretaker.get_inventory_amount(SimulationIds.RESOURCE_FOOD), 1.0)
+			and zora_state.get_reserved_by() == caretaker_id
+		),
+		"Legacy work should resume beside Zora without losing its saved progress",
+	)
+
+	await _unload_world(main_scene)
+
+
+func _test_post_pickup_restore_continuation() -> void:
+	var fixture := await _load_world()
+	var main_scene: Node = fixture["main"]
+	var manager: Node = fixture["manager"]
+	var view: Node = fixture["view"]
+	var pantry_node := StorageNode.get_by_id(SimulationIds.STORAGE_VILLAGE_PANTRY) as StorageNode
+	var zora_node := AnimalNode.get_by_id(SimulationIds.ANIMAL_ZORA)
+	var pantry: StorageStateRecord = manager.get_pantry()
+	var zora_state: AnimalStateRecord = manager.animal_care.get_state(SimulationIds.ANIMAL_ZORA)
+	if pantry_node == null or zora_node == null or pantry == null or zora_state == null:
+		_check(false, "The restore proof needs the authored pantry and Zora")
+		await _unload_world(main_scene)
+		return
+
+	_prepare_population(manager, view)
+	_set_pantry_food(manager, 2.0)
+	zora_state.set_hunger(72.0)
+	var caretaker: SimNPC = manager.npcs[0]
+	var caretaker_id := caretaker.id
+	var origin := zora_node.get_interaction_position()
+	_prepare_feed_task(manager, view, caretaker, origin)
+	_check(
+		manager.resolve_npc_target(caretaker.id, origin),
+		"The restore caretaker should resolve Zora's two-leg delivery",
+	)
+	_arrive_at_current_target(manager, view, caretaker)
+
+	var midpoint_json: String = manager.serialize_state()
+	var midpoint_checksum: String = manager.get_state_checksum()
+	var midpoint_position := caretaker.position
+	var midpoint_destination := caretaker.travel_target_position
+	var midpoint_pantry := pantry.get_amount(SimulationIds.RESOURCE_FOOD)
+	_check(
+		(
+			caretaker.target_id == SimulationIds.ANIMAL_ZORA
+			and caretaker.task_state == SimNPC.TASK_STATE_TRAVELING
+			and caretaker.has_travel_target
+			and caretaker.travel_target_position.is_equal_approx(
+				zora_node.get_interaction_position()
+			)
+			and is_equal_approx(caretaker.get_inventory_amount(SimulationIds.RESOURCE_FOOD), 1.0)
+			and zora_state.get_reserved_by() == caretaker.id
+			and (
+				_events_for(manager, SimulationIds.EVENT_STORAGE_WITHDRAWN, caretaker.id).size()
+				== 1
+			)
+			and _events_for(manager, SimulationIds.EVENT_ANIMAL_FED, caretaker.id).is_empty()
+		),
+		"The save point should be after one real pickup and before the exact goat delivery",
+	)
+
+	_arrive_at_current_target(manager, view, caretaker)
+	var continuation_ticks := int(ceil(caretaker.task_duration))
+	for _tick in range(continuation_ticks):
+		manager.simulate_tick()
+	var uninterrupted_checksum: String = manager.get_state_checksum()
+	var uninterrupted_feed_events := _events_for(
+		manager, SimulationIds.EVENT_ANIMAL_FED, caretaker_id
+	)
+	_check(
+		(
+			uninterrupted_feed_events.size() == 1
+			and (
+				_events_for(manager, SimulationIds.EVENT_STORAGE_WITHDRAWN, caretaker_id).size()
+				== 1
+			)
+		),
+		"The uninterrupted control should finish with one pickup and one feed",
+	)
+
+	_check(
+		manager.restore_state_from_json(midpoint_json),
+		"A post-pickup in-progress feed state should pass the complete save schema",
+	)
+	_freeze_visuals(view)
+	caretaker = _find_npc(manager.npcs, caretaker_id)
+	pantry = manager.get_pantry()
+	zora_state = manager.animal_care.get_state(SimulationIds.ANIMAL_ZORA)
+	var restored_visual := _get_visual(view, caretaker_id)
+	var restored_carried_food := _get_carried_food(view, caretaker_id)
+	_check(
+		(
+			caretaker != null
+			and pantry != null
+			and zora_state != null
+			and manager.get_state_checksum() == midpoint_checksum
+			and caretaker.position.is_equal_approx(midpoint_position)
+			and caretaker.travel_target_position.is_equal_approx(midpoint_destination)
+			and caretaker.current_task == SimulationIds.ACTION_FEED_ANIMAL
+			and caretaker.task_state == SimNPC.TASK_STATE_TRAVELING
+			and caretaker.target_id == SimulationIds.ANIMAL_ZORA
+			and caretaker.has_travel_target
+			and is_equal_approx(caretaker.get_inventory_amount(SimulationIds.RESOURCE_FOOD), 1.0)
+			and is_equal_approx(pantry.get_amount(SimulationIds.RESOURCE_FOOD), midpoint_pantry)
+			and zora_state.get_reserved_by() == caretaker_id
+			and restored_visual != null
+			and restored_visual.global_position.is_equal_approx(midpoint_position)
+			and restored_visual.get("current_target") == midpoint_destination
+			and restored_carried_food != null
+			and restored_carried_food.visible
+			and (
+				_events_for(manager, SimulationIds.EVENT_STORAGE_WITHDRAWN, caretaker_id).size()
+				== 1
+			)
+			and _events_for(manager, SimulationIds.EVENT_ANIMAL_FED, caretaker_id).is_empty()
+		),
+		"Restore should retain exact claim, route, carried food, pickup history, and checksum",
+	)
+	if caretaker == null:
+		await _unload_world(main_scene)
+		return
+
+	_arrive_at_current_target(manager, view, caretaker)
+	for _tick in range(continuation_ticks):
+		manager.simulate_tick()
+	var restored_feed_events := _events_for(manager, SimulationIds.EVENT_ANIMAL_FED, caretaker_id)
+	_check(
+		(
+			manager.get_state_checksum() == uninterrupted_checksum
+			and (
+				_events_for(manager, SimulationIds.EVENT_STORAGE_WITHDRAWN, caretaker_id).size()
+				== 1
+			)
+			and restored_feed_events.size() == 1
+			and _is_exact_feed(
+				restored_feed_events[0],
+				caretaker_id,
+				SimulationIds.ANIMAL_ZORA,
+				zora_state,
+			)
+			and is_equal_approx(caretaker.get_inventory_amount(SimulationIds.RESOURCE_FOOD), 0.0)
+			and is_equal_approx(pantry.get_amount(SimulationIds.RESOURCE_FOOD), midpoint_pantry)
+		),
+		"Restored continuation should match uninterrupted state without replaying either transfer",
+	)
+
+	await _unload_world(main_scene)
+
+
+func _load_world() -> Dictionary:
+	var main_scene: Node = load("res://main.tscn").instantiate()
+	root.add_child(main_scene)
+	await process_frame
+	for _frame in 3:
+		await physics_frame
+	var manager: Node = main_scene.get_node("SimulationManager")
+	manager.set_process(false)
+	var view: Node = main_scene.get_node("WorldViewManager")
+	_freeze_visuals(view)
+	return {"main": main_scene, "manager": manager, "view": view}
+
+
+func _unload_world(main_scene: Node) -> void:
+	main_scene.queue_free()
+	await process_frame
+	await physics_frame
+
+
+func _prepare_population(manager: Node, view: Node) -> void:
+	for npc in manager.npcs:
+		manager.release_npc_reservation(npc.id)
+		npc.inventory.clear()
+		npc.hunger = 20.0
+		npc.energy = 100.0
+		npc.is_starving = false
+		npc.starvation_ticks = 0
+		npc.set_task(SimulationIds.ACTION_WANDER, 1000.0)
+		npc.start_working()
+		(
+			manager
+			. emit_signal(
+				"npc_inventory_changed",
+				npc,
+				SimulationIds.RESOURCE_FOOD,
+				npc.get_inventory_amount(SimulationIds.RESOURCE_FOOD),
+			)
+		)
+	_freeze_visuals(view)
+
+
+func _prepare_feed_task(manager: Node, view: Node, npc: SimNPC, origin: Vector3) -> void:
+	manager.release_npc_reservation(npc.id)
+	npc.inventory.clear()
+	npc.target_id = &""
+	npc.has_travel_target = false
+	npc.position = origin
+	npc.set_task(SimulationIds.ACTION_FEED_ANIMAL)
+	var visual := _get_visual(view, npc.id)
+	if visual != null:
+		visual.global_position = origin
+	manager.synchronize_npc_position(npc.id, origin)
+
+
+func _set_pantry_food(manager: Node, amount: float) -> void:
+	var pantry: StorageStateRecord = manager.get_pantry()
+	(
+		pantry
+		. withdraw(
+			SimulationIds.RESOURCE_FOOD,
+			pantry.get_amount(SimulationIds.RESOURCE_FOOD),
+		)
+	)
+	pantry.deposit(SimulationIds.RESOURCE_FOOD, amount)
+	manager.economy.sync_resource(SimulationIds.RESOURCE_FOOD)
+
+
+func _arrive_at_current_target(manager: Node, view: Node, npc: SimNPC) -> void:
+	var visual := _get_visual(view, npc.id)
+	if visual != null:
+		visual.set_physics_process(false)
+		visual.global_position = npc.travel_target_position
+	manager.synchronize_npc_position(npc.id, npc.travel_target_position)
+	manager.notify_npc_arrived(npc.id)
+
+
+func _freeze_visuals(view: Node) -> void:
+	for visual in view.active_npc_visuals.values():
+		visual.set_physics_process(false)
+
+
+func _get_visual(view: Node, npc_id: int) -> Node3D:
+	return view.active_npc_visuals.get(npc_id) as Node3D
+
+
+func _get_carried_food(view: Node, npc_id: int) -> MeshInstance3D:
+	var visual := _get_visual(view, npc_id)
+	if visual == null:
+		return null
+	return visual.get_node("CarriedFood") as MeshInstance3D
+
+
+func _find_npc(npcs: Array[SimNPC], npc_id: int) -> SimNPC:
+	for npc in npcs:
+		if npc.id == npc_id:
+			return npc
+	return null
+
+
+func _find_npc_record(records: Array[NPCStateRecord], npc_id: int) -> NPCStateRecord:
+	for record in records:
+		if int(record.data["id"]) == npc_id:
+			return record
+	return null
+
+
+func _events_for(
+	manager: Node, event_type: StringName, actor_id: int
+) -> Array[EconomicEventRecord]:
+	var matching: Array[EconomicEventRecord] = []
+	for event in manager.economic_events:
+		if (
+			StringName(event.data["event_type"]) == event_type
+			and int(event.data["actor_id"]) == actor_id
+		):
+			matching.append(event)
+	return matching
+
+
+func _events_of_type(manager: Node, event_type: StringName) -> Array[EconomicEventRecord]:
+	var matching: Array[EconomicEventRecord] = []
+	for event in manager.economic_events:
+		if StringName(event.data["event_type"]) == event_type:
+			matching.append(event)
+	return matching
+
+
+func _is_exact_withdrawal(
+	event: EconomicEventRecord, actor_id: int, pantry_position: Vector3
+) -> bool:
+	return (
+		event != null
+		and int(event.data["actor_id"]) == actor_id
+		and StringName(event.data["source_id"]) == SimulationIds.STORAGE_VILLAGE_PANTRY
+		and (StringName(event.data["destination_id"]) == SimulationIds.npc_inventory_id(actor_id))
+		and StringName(event.data["item_id"]) == SimulationIds.RESOURCE_FOOD
+		and is_equal_approx(float(event.data["amount"]), 1.0)
+		and event.get_world_position().is_equal_approx(pantry_position)
+	)
+
+
+func _is_exact_feed(
+	event: EconomicEventRecord,
+	actor_id: int,
+	animal_id: StringName,
+	animal_state: AnimalStateRecord,
+) -> bool:
+	return (
+		event != null
+		and animal_state != null
+		and int(event.data["actor_id"]) == actor_id
+		and StringName(event.data["source_id"]) == SimulationIds.npc_inventory_id(actor_id)
+		and StringName(event.data["destination_id"]) == animal_id
+		and StringName(event.data["item_id"]) == SimulationIds.RESOURCE_FOOD
+		and is_equal_approx(float(event.data["amount"]), 1.0)
+		and event.get_world_position().is_equal_approx(animal_state.get_position())
+	)
+
+
+func _check(condition: bool, message: String) -> void:
+	if not condition:
+		failures.append(message)
+
+
+func _finish() -> void:
+	if failures.is_empty():
+		print("[TEST] Animal food delivery passed")
+		quit(0)
+		return
+	for failure in failures:
+		push_error("[TEST] " + failure)
+	quit(1)

tests/animal_food_delivery_test.gd.uid

@@ -0,0 +1 @@
+uid://rx6bphs7qvyq

tests/animal_pair_vertical_slice_test.gd

@@ -192,9 +192,13 @@ func _run() -> void:
 	var dunja_hunger_before := dunja_state.get_hunger()
 	var dunja_fed_tick_before := dunja_state.get_last_fed_tick()
 	var dunja_reservation_before := dunja_state.get_reserved_by()
+	_check(
+		manager.animal_care.collect_feed_supply(zora_caretaker),
+		"The restored caretaker should collect one real pantry food for Zora",
+	)
 	_check(
 		manager.feed_animal(SimulationIds.ANIMAL_ZORA, zora_caretaker_id),
-		"The restored exact Zora claim should complete one real feed operation",
+		"The restored exact Zora claim should deliver its carried food",
 	)
 	_check(
 		(
@@ -212,20 +216,23 @@ func _run() -> void:
 	)
 	_check(
 		is_equal_approx(pantry.get_amount(SimulationIds.RESOURCE_FOOD), pantry_food_before - 1.0),
-		"Feeding exactly one goat should consume exactly one pantry food",
+		"Collecting for exactly one goat should withdraw exactly one pantry food",
 	)
 	var feed_event := _latest_feed_event(manager)
 	_check(
 		(
 			feed_event != null
 			and int(feed_event.data["actor_id"]) == zora_caretaker_id
-			and StringName(feed_event.data["source_id"]) == SimulationIds.STORAGE_VILLAGE_PANTRY
+			and (
+				StringName(feed_event.data["source_id"])
+				== SimulationIds.npc_inventory_id(zora_caretaker_id)
+			)
 			and StringName(feed_event.data["destination_id"]) == SimulationIds.ANIMAL_ZORA
 			and StringName(feed_event.data["item_id"]) == SimulationIds.RESOURCE_FOOD
 			and is_equal_approx(float(feed_event.data["amount"]), 1.0)
 			and feed_event.get_world_position().is_equal_approx(zora_state.get_position())
 		),
-		"The feed event should record the exact caretaker, pantry, Zora destination, and amount",
+		"The feed event should record the exact caretaker inventory, Zora, and amount",
 	)
 
 	_finish()

tests/simulation_definitions_test.gd

@@ -96,7 +96,7 @@ func _test_definition_backed_behavior() -> void:
 			and feed.completion_cost_resource_id == SimulationIds.RESOURCE_FOOD
 			and is_equal_approx(feed.completion_cost_amount, 1.0)
 		),
-		"Feed-animal should target an animal and declare its exact pantry-food cost"
+		"Feed-animal should target an animal and declare its exact one-food cost"
 	)
 
 

tests/simulation_state_serialization_test.gd

@@ -11,6 +11,7 @@ func _run() -> void:
 	await _test_deterministic_continuation()
 	await _test_resource_state_round_trip()
 	_test_legacy_npc_migration()
+	_test_npc_inventory_schema_rejection()
 	_test_legacy_resource_migration()
 	_test_legacy_world_storage_migration()
 	_test_previous_world_event_migration()
@@ -275,6 +276,43 @@ func _test_legacy_npc_migration() -> void:
 	)
 
 
+func _test_npc_inventory_schema_rejection() -> void:
+	var npc := SimNPC.new(89, "InventoryNPC", SimulationIds.PROFESSION_FARMER, 5.0, 5.0)
+	var valid_inventory := NPCStateRecord.capture(npc).to_dictionary()
+	var food_id := String(SimulationIds.RESOURCE_FOOD)
+	var invalid_cases := [
+		[{food_id: -1.0}, "negative amounts"],
+		[{food_id: NAN}, "NaN amounts"],
+		[{food_id: INF}, "infinite amounts"],
+		[{food_id: "1.0"}, "string amounts"],
+		[{food_id: true}, "boolean amounts"],
+		[{food_id: null}, "null amounts"],
+		[{"": 1.0}, "empty item IDs"],
+		[{1: 1.0, "1": 2.0}, "item IDs that collide after string normalization"],
+	]
+	for invalid_case in invalid_cases:
+		var invalid_inventory := valid_inventory.duplicate(true)
+		invalid_inventory["inventory"] = invalid_case[0]
+		_check(
+			NPCStateRecord.from_dictionary(invalid_inventory) == null,
+			"NPC records should reject inventory %s" % invalid_case[1]
+		)
+	var normalizable_inventory := valid_inventory.duplicate(true)
+	normalizable_inventory["inventory"] = {SimulationIds.RESOURCE_FOOD: 2}
+	var normalized := NPCStateRecord.from_dictionary(normalizable_inventory)
+	_check(normalized != null, "NPC records should accept normalizable inventory values")
+	if normalized != null:
+		var normalized_inventory: Dictionary = normalized.data["inventory"]
+		_check(
+			(
+				normalized_inventory.has(String(SimulationIds.RESOURCE_FOOD))
+				and typeof(normalized_inventory.keys()[0]) == TYPE_STRING
+				and typeof(normalized_inventory.values()[0]) == TYPE_FLOAT
+			),
+			"NPC records should normalize inventory IDs to strings and amounts to floats"
+		)
+
+
 func _test_legacy_world_storage_migration() -> void:
 	var manager := _create_manager(55)
 	var legacy_data: Dictionary = manager.create_state_record().to_dictionary()