@beremaran/godot-agent-loop 1.0.1 → 1.1.0

package/addons/godot_agent_loop/plugin.gd

@@ -8,8 +8,12 @@ extends EditorPlugin
 var _server: TCPServer
 var _peer: StreamPeerTCP
 var _buffer: PackedByteArray = PackedByteArray()
-var _port: int = 9091
+var _port: int = 0
 var _secret: String = ""
+var _project_path: String = ""
+var _editor_pid: int = 0
+var _editor_start_identity: String = ""
+var _session_path: String = ""
 var _activity_dock: VBoxContainer
 var _activity_list: ItemList
 var _connection_status: Label
@@ -21,29 +25,51 @@ var _session_authenticated: bool = false
 var _server_version: String = ""
 var _last_history_id: int = EditorUndoRedoManager.GLOBAL_HISTORY
 var _activity_entries: Array[Dictionary] = []
+var _activity_event_ids: Dictionary = {}
 var _last_filesystem_sync: Dictionary = {}
+var _saved_history_versions: Dictionary = {}
 const MAX_ACTIVITY_ENTRIES: int = 200
-const PROTOCOL_VERSION: String = "1"
-const ADDON_VERSION: String = "1.0.1"
+const PROTOCOL_VERSION: String = "2"
+const ADDON_VERSION: String = "1.1.0"
+const SESSION_DIRECTORY: String = ".godot/godot_agent_loop"
+const SESSION_FILE: String = "editor-session.json"
 
 func _enter_tree() -> void:
 	set_process(true)
 	_port = _read_port()
 	_secret = OS.get_environment("GODOT_MCP_EDITOR_SECRET")
+	if _secret.is_empty():
+		_secret = Marshalls.raw_to_base64(Crypto.new().generate_random_bytes(32))
+	_project_path = ProjectSettings.globalize_path("res://").trim_suffix("/")
+	_editor_pid = OS.get_process_id()
+	_editor_start_identity = "%d-%d" % [_editor_pid, Time.get_ticks_usec()]
+	_session_path = _project_path.path_join(SESSION_DIRECTORY).path_join(SESSION_FILE)
 	_driver_paused = OS.get_environment("GODOT_MCP_EDITOR_START_PAUSED").strip_edges().to_lower() in ["1", "true", "yes"]
 	_server = TCPServer.new()
 	_create_activity_dock()
+	var scene_changed_error: Error = scene_changed.connect(_on_scene_changed) as Error
+	if scene_changed_error != OK:
+		push_error("Godot Agent Loop could not observe scene changes: %s" % error_string(scene_changed_error))
+	var scene_saved_error: Error = scene_saved.connect(_on_scene_saved) as Error
+	if scene_saved_error != OK:
+		push_error("Godot Agent Loop could not observe scene saves: %s" % error_string(scene_saved_error))
 	var error: int = _server.listen(_port, "127.0.0.1")
 	if error != OK:
 		push_error("Godot Agent Loop editor bridge could not listen on %d: %s" % [_port, error_string(error)])
 		_set_connection_status("Unavailable — port %d: %s" % [_port, error_string(error)])
-	elif _secret.is_empty():
-		_set_connection_status("Waiting — relaunch the editor through Godot Agent Loop")
 	else:
-		_set_connection_status("Waiting for an authenticated agent")
+		_port = _server.get_local_port()
+		var discovery_error: Error = _write_discovery_record()
+		if discovery_error != OK:
+			push_error("Godot Agent Loop could not publish editor discovery: %s" % error_string(discovery_error))
+			_set_connection_status("Unavailable — discovery record failed")
+			_server.stop()
+		else:
+			_set_connection_status("Waiting for an authenticated agent")
 
 func _exit_tree() -> void:
 	set_process(false)
+	_remove_owned_discovery_record()
 	if _peer != null:
 		_peer.disconnect_from_host()
 	_peer = null
@@ -120,7 +146,7 @@ func _handle_request(line: String) -> void:
 	if not _session_authenticated:
 		_send({"id": request.get("id", null), "error": "handshake_required", "protocol_version": PROTOCOL_VERSION})
 		return
-	var result: Dictionary = _dispatch(command, request.get("params", {}))
+	var result: Dictionary = await _dispatch(command, request.get("params", {}))
 	result["id"] = request.get("id", null)
 	_send(result)
 
@@ -134,7 +160,11 @@ func _dispatch(command: String, raw_params: Variant) -> Dictionary:
 		"driver_state":
 			return _driver_state()
 		"filesystem_changed":
-			return _sync_filesystem(params)
+			return await _sync_filesystem(params)
+		"transaction":
+			return await _editor_transaction(params)
+		"resource_transaction":
+			return _editor_resource_transaction(params)
 		"select":
 			return _select(params)
 		"save":
@@ -167,7 +197,7 @@ func _dispatch(command: String, raw_params: Variant) -> Dictionary:
 			var redo_history: UndoRedo = redo_manager.get_history_undo_redo(_last_history_id)
 			return {"success": redo_history.redo(), "action": "redo"}
 		_:
-			return {"error": "unknown_command", "allowed": ["inspect", "activity", "driver_state", "filesystem_changed", "select", "save", "reload", "open_scene", "set_property", "rename_node", "undo", "redo"]}
+			return {"error": "unknown_command", "allowed": ["inspect", "activity", "driver_state", "filesystem_changed", "transaction", "resource_transaction", "select", "save", "reload", "open_scene", "set_property", "rename_node", "undo", "redo"]}
 
 func _handshake(raw_params: Variant) -> Dictionary:
 	var params: Dictionary = raw_params if raw_params is Dictionary else {}
@@ -191,6 +221,10 @@ func _handshake(raw_params: Variant) -> Dictionary:
 		"addon_version": ADDON_VERSION,
 		"server_version": _server_version,
 		"godot_version": Engine.get_version_info().get("string", "unknown"),
+		"project_path": _project_path,
+		"editor_pid": _editor_pid,
+		"editor_start_identity": _editor_start_identity,
+		"paused": _driver_paused,
 	}
 
 func _create_activity_dock() -> void:
@@ -233,7 +267,7 @@ func _create_activity_dock() -> void:
 	setup_help.name = "SetupHelp"
 	setup_help.fit_content = true
 	setup_help.custom_minimum_size = Vector2(320, 96)
-	setup_help.text = "Claude Code / Codex: install the Godot Agent Loop plugin\nOpenCode: godot-agent-loop setup opencode --write\nPi: pi install npm:@beremaran/godot-agent-loop\nRelaunch the editor through the MCP launch_editor tool to authenticate."
+	setup_help.text = "Install and enable this addon once for interactive projects.\nOpen Godot normally before or after the MCP; this dock waits for the matching authenticated agent.\nUse launch_editor only when no editor is already open."
 	_activity_dock.add_child(setup_help)
 	add_control_to_dock(DOCK_SLOT_RIGHT_BL, _activity_dock)
 
@@ -256,11 +290,12 @@ func _driver_state() -> Dictionary:
 	return {"success": true, "paused": _driver_paused, "agent_driving": not _driver_paused}
 
 func _record_activity(params: Dictionary) -> Dictionary:
-	var event: String = str(params.get("event", ""))
-	if not event in ["request_started", "request_finished", "request_timed_out"]:
-		return {"error": "invalid_activity_event"}
-	var command: String = str(params.get("command", "unknown"))
-	var target: String = str(params.get("target", "game"))
+	var event_id: int = _variant_int(params.get("event_id", 0))
+	if event_id > 0 and _activity_event_ids.has(event_id):
+		return {"success": true, "deduplicated": true, "event_id": event_id, "activity_count": _activity_entries.size()}
+	var event: String = str(params.get("event", params.get("phase", "state")))
+	var command: String = str(params.get("command", params.get("tool", "unknown")))
+	var target: String = str(params.get("target", params.get("target_backend", "unknown")))
 	var outcome: String = str(params.get("outcome", "running"))
 	var raw_duration_ms: Variant = params.get("duration_ms", 0)
 	var duration_ms: int = 0
@@ -270,28 +305,66 @@ func _record_activity(params: Dictionary) -> Dictionary:
 		var float_duration_ms: float = raw_duration_ms
 		duration_ms = roundi(float_duration_ms)
 	var correlation_id: String = str(params.get("correlation_id", ""))
-	var marker: String = "…" if event == "request_started" else "✓" if outcome == "success" else "✗"
-	var suffix: String = "" if event == "request_started" else " · %d ms" % duration_ms
+	var running: bool = outcome == "running" or event in ["request_started", "start"]
+	var marker: String = "…" if running else "✓" if outcome == "success" else "↪" if outcome == "fallback" else "Ⅱ" if outcome == "paused" else "!" if outcome == "conflict" else "✗"
+	var suffix: String = "" if running else " · %d ms" % duration_ms
 	var text: String = "%s %s → %s%s" % [marker, command, target, suffix]
 	var entry: Dictionary = {
-		"event": event, "correlation_id": correlation_id, "command": command,
+		"event_id": event_id, "event": event, "correlation_id": correlation_id, "command": command,
 		"target": target, "outcome": outcome, "duration_ms": duration_ms, "text": text,
 	}
 	_activity_entries.append(entry)
+	if event_id > 0: _activity_event_ids[event_id] = true
 	var item_index: int = _activity_list.add_item(text)
 	_activity_list.set_item_tooltip(item_index, correlation_id)
-	if event != "request_started":
-		var color := Color(0.35, 0.85, 0.45) if outcome == "success" else Color(1.0, 0.4, 0.35)
+	if not running:
+		var color := Color(0.35, 0.85, 0.45) if outcome == "success" else Color(1.0, 0.75, 0.25) if outcome in ["fallback", "paused", "conflict"] else Color(1.0, 0.4, 0.35)
 		_activity_list.set_item_custom_fg_color(item_index, color)
+	if outcome == "paused": _set_connection_status("Paused — human editing")
+	elif outcome == "conflict": _set_connection_status("Conflict — unsaved changes preserved")
 	while _activity_entries.size() > MAX_ACTIVITY_ENTRIES:
-		_activity_entries.pop_front()
+		var removed: Dictionary = _activity_entries.pop_front()
+		var removed_id: int = _variant_int(removed.get("event_id", 0))
+		if removed_id > 0:
+			@warning_ignore("return_value_discarded")
+			_activity_event_ids.erase(removed_id)
 		_activity_list.remove_item(0)
 	return {"success": true, "activity_count": _activity_entries.size()}
 
 func _sync_filesystem(params: Dictionary) -> Dictionary:
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
-	filesystem.scan()
 	var scene_path: String = str(params.get("scene_path", ""))
+	var resource_path: String = str(params.get("resource_path", ""))
+	var root_before: Node = EditorInterface.get_edited_scene_root()
+	var open_scene_before: String = "" if root_before == null else root_before.scene_file_path
+	var selection_before: Array[String] = []
+	for selected_node: Node in EditorInterface.get_selection().get_selected_nodes():
+		selection_before.append(str(selected_node.get_path()))
+	if root_before != null and not scene_path.is_empty() and root_before.scene_file_path == scene_path and _scene_has_unsaved_changes(root_before):
+		_last_filesystem_sync = {
+			"success": false, "error": "unsaved_conflict", "state": "unsaved_conflict",
+			"scene_path": scene_path, "resource_path": resource_path,
+			"observed_target_state": {
+				"edited_scene": open_scene_before, "selection": selection_before,
+				"unsaved": true, "reloaded": false,
+			},
+		}
+		_set_connection_status("Conflict — unsaved editor changes preserved")
+		return _last_filesystem_sync.duplicate(true)
+	_set_connection_status("Synchronizing filesystem")
+	filesystem.scan()
+	var frames_waited: int = 0
+	while filesystem.is_scanning() and frames_waited < 600:
+		await get_tree().process_frame
+		frames_waited += 1
+	if filesystem.is_scanning():
+		_last_filesystem_sync = {
+			"success": false, "error": "sync_timeout", "state": "syncing",
+			"scene_path": scene_path, "resource_path": resource_path,
+			"observed_target_state": {"scan_complete": false, "frames_waited": frames_waited},
+		}
+		_set_connection_status("Connected — filesystem synchronization timed out")
+		return _last_filesystem_sync.duplicate(true)
 	var root: Node = EditorInterface.get_edited_scene_root()
 	var reloaded: bool = false
 	if root != null and not scene_path.is_empty() and root.scene_file_path == scene_path:
@@ -301,14 +374,75 @@ func _sync_filesystem(params: Dictionary) -> Dictionary:
 	var focused: bool = false
 	if reloaded and not focus_path.is_empty():
 		focused = _focus_editor_node(focus_path)
+	var root_after: Node = EditorInterface.get_edited_scene_root()
+	var selection_after: Array[String] = []
+	for selected_node: Node in EditorInterface.get_selection().get_selected_nodes():
+		selection_after.append(str(selected_node.get_path()))
+	var scene_readback: Dictionary = _readback_sync_target(scene_path, true)
+	var resource_readback: Dictionary = _readback_sync_target(resource_path, false)
+	var scene_visible: bool = scene_readback.get("readable", false) == true
+	var resource_visible: bool = resource_readback.get("readable", false) == true
+	var target_readable: bool = scene_visible and resource_visible
+	var observed_target_state: Dictionary = {
+		"scan_complete": true,
+		"frames_waited": frames_waited,
+		"edited_scene": "" if root_after == null else root_after.scene_file_path,
+		"selection": selection_after,
+		"scene_visible": scene_visible,
+		"resource_visible": resource_visible,
+		"scene_readback": scene_readback,
+		"resource_readback": resource_readback,
+		"independently_reopened": target_readable,
+		"reloaded": reloaded,
+		"focused": focused,
+		"preserved_context": {
+			"open_scene": open_scene_before == ("" if root_after == null else root_after.scene_file_path),
+			"selection_before": selection_before,
+			"viewport": "public_api_unavailable",
+			"inspector": "restored_to_focus_target" if focused else "unchanged_or_unavailable",
+		},
+	}
 	_last_filesystem_sync = {
-		"success": true, "rescanned": true, "scene_path": scene_path,
-		"resource_path": str(params.get("resource_path", "")), "reloaded": reloaded,
+		"success": target_readable, "rescanned": true, "scene_path": scene_path,
+		"resource_path": resource_path, "reloaded": reloaded,
 		"command": str(params.get("command", "")), "focus_path": focus_path,
-		"focused": focused,
+		"focused": focused, "state": "connected",
+		"observed_target_state": observed_target_state,
 	}
+	if not target_readable:
+		_last_filesystem_sync["error"] = "target_not_editor_readable"
+		_last_filesystem_sync["state"] = "target_unreadable"
+		_set_connection_status("Connected — synchronized target is unreadable")
+	else:
+		_set_connection_status("Authenticated — synchronized")
 	return _last_filesystem_sync.duplicate(true)
 
+func _readback_sync_target(resource_path: String, require_packed_scene: bool) -> Dictionary:
+	if resource_path.is_empty():
+		return {"requested": false, "exists": true, "readable": true, "reader": "none"}
+	var absolute_path: String = ProjectSettings.globalize_path(resource_path)
+	var file_exists: bool = FileAccess.file_exists(absolute_path)
+	var extension: String = resource_path.get_extension().to_lower()
+	var recognized_extensions: PackedStringArray = ResourceLoader.get_recognized_extensions_for_type("Resource")
+	var resource_format: bool = require_packed_scene or ResourceLoader.exists(resource_path) or extension in recognized_extensions
+	if resource_format:
+		var loaded: Resource = null
+		if file_exists:
+			loaded = ResourceLoader.load(resource_path, "PackedScene" if require_packed_scene else "", ResourceLoader.CACHE_MODE_IGNORE)
+		var resource_readable: bool = loaded is PackedScene if require_packed_scene else loaded != null
+		return {
+			"requested": true, "exists": file_exists, "readable": resource_readable,
+			"reader": "resource_loader", "resource_type": "" if loaded == null else loaded.get_class(),
+		}
+	var file: FileAccess = FileAccess.open(absolute_path, FileAccess.READ) if file_exists else null
+	var file_readable: bool = file != null
+	if file != null:
+		file.close()
+	return {
+		"requested": true, "exists": file_exists, "readable": file_readable,
+		"reader": "file_access", "resource_type": "",
+	}
+
 func _inspect() -> Dictionary:
 	var root: Node = EditorInterface.get_edited_scene_root()
 	var selected: Array[String] = []
@@ -402,6 +536,573 @@ func _commit_property_action(target: Node, property: String, before: Variant, af
 	_last_history_id = manager.get_object_history_id(target)
 	return {"success": true, "property": property, "before": before, "after": target.get(property), "undo_recorded": true}
 
+func _editor_transaction(params: Dictionary) -> Dictionary:
+	if _driver_paused:
+		return {"error": "paused", "state": "paused"}
+	var scene_path: String = _resource_path(str(params.get("scene_path", "")))
+	var action_name: String = str(params.get("name", "Godot Agent Loop transaction")).strip_edges()
+	var operations_variant: Variant = params.get("operations", [])
+	if scene_path.is_empty() or action_name.is_empty() or not operations_variant is Array:
+		return {"error": "scene_path, name, and operations are required"}
+	var operations: Array = operations_variant
+	if operations.is_empty() or operations.size() > 256:
+		return {"error": "operations must contain 1 to 256 items"}
+	var created_scene: bool = false
+	if not ResourceLoader.exists(scene_path):
+		var root_type: String = str(params.get("root_type", "Node"))
+		if not ClassDB.is_parent_class(root_type, "Node"):
+			return {"error": "invalid_root_type", "root_type": root_type}
+		var new_root_variant: Variant = ClassDB.instantiate(root_type)
+		if not new_root_variant is Node:
+			return {"error": "root_type_not_instantiable", "root_type": root_type}
+		var new_root: Node = new_root_variant
+		new_root.name = scene_path.get_file().get_basename().to_pascal_case()
+		var preflight: Dictionary = _validate_transaction(new_root, operations)
+		if preflight.has("error"):
+			new_root.free()
+			return preflight
+		_discard_transaction_stages(preflight.get("stages", []))
+		var initial_scene := PackedScene.new()
+		var pack_error: Error = initial_scene.pack(new_root)
+		if pack_error != OK:
+			new_root.free()
+			return {"error": "create_scene_pack_failed", "error_code": pack_error}
+		var directory_error: Error = _ensure_resource_parent_directory(scene_path)
+		if directory_error != OK:
+			new_root.free()
+			return {"error": "create_scene_directory_failed", "error_code": directory_error}
+		var create_error: Error = ResourceSaver.save(initial_scene, scene_path)
+		new_root.free()
+		if create_error != OK:
+			return {"error": "create_scene_save_failed", "error_code": create_error}
+		created_scene = true
+	EditorInterface.open_scene_from_path(scene_path)
+	var open_frames: int = 0
+	while open_frames < 120:
+		var candidate: Node = EditorInterface.get_edited_scene_root()
+		if candidate != null and candidate.scene_file_path == scene_path:
+			break
+		await get_tree().process_frame
+		open_frames += 1
+	var root: Node = EditorInterface.get_edited_scene_root()
+	if root == null or root.scene_file_path != scene_path:
+		return _rollback_created_transaction({"error": "scene_open_failed", "scene_path": scene_path}, scene_path, created_scene)
+	if _scene_has_unsaved_changes(root):
+		return _rollback_created_transaction({"error": "unsaved_conflict", "state": "unsaved_conflict", "scene_path": scene_path}, scene_path, created_scene)
+	var validation: Dictionary = _validate_transaction(root, operations)
+	if validation.has("error"):
+		return _rollback_created_transaction(validation, scene_path, created_scene)
+	var stages: Array = validation.get("stages", [])
+	var undo_recorded: bool = not stages.is_empty()
+	if undo_recorded:
+		var manager: EditorUndoRedoManager = EditorInterface.get_editor_undo_redo()
+		if manager == null:
+			_discard_transaction_stages(stages)
+			return _rollback_created_transaction({"error": "undo_redo_unavailable"}, scene_path, created_scene)
+		manager.create_action(action_name)
+		for stage_variant: Variant in stages:
+			var stage: Dictionary = stage_variant
+			_apply_transaction_stage(manager, root, stage)
+		manager.commit_action()
+		_last_history_id = manager.get_object_history_id(root)
+	var focus_path: String = str(params.get("focus_path", validation.get("focus_path", "")))
+	var focused: bool = false
+	if not focus_path.is_empty():
+		focused = _focus_editor_node(focus_path)
+	var saved: bool = false
+	var save_error: Error = OK
+	if _variant_bool(params.get("save", true)):
+		save_error = EditorInterface.save_scene()
+		saved = save_error == OK
+	if save_error != OK:
+		return _rollback_created_transaction({"error": "scene_save_failed", "error_code": save_error, "undo_recorded": undo_recorded}, scene_path, created_scene)
+	var persisted: Dictionary = _independent_scene_readback(scene_path)
+	if persisted.has("error"):
+		return _rollback_created_transaction({"error": "independent_readback_failed", "details": persisted, "undo_recorded": undo_recorded}, scene_path, created_scene)
+	return {
+		"success": true,
+		"backend": "editor",
+		"transaction_name": action_name,
+		"operation_count": operations.size(),
+		"undo_recorded": undo_recorded,
+		"saved": saved,
+		"scene_created": created_scene,
+		"creation_fallback": _creation_fallback(created_scene, "initial PackedScene save required before opening"),
+		"focused": focused,
+		"focus_path": focus_path,
+		"observed_target_state": persisted,
+	}
+
+func _rollback_created_transaction(result: Dictionary, scene_path: String, created_scene: bool) -> Dictionary:
+	if not created_scene:
+		return result
+	var remove_error: Error = DirAccess.remove_absolute(ProjectSettings.globalize_path(scene_path))
+	result["created_scene_rolled_back"] = remove_error in [OK, ERR_DOES_NOT_EXIST]
+	if remove_error not in [OK, ERR_DOES_NOT_EXIST]:
+		result["rollback_error_code"] = remove_error
+	return result
+
+func _discard_transaction_stages(stages_variant: Variant) -> void:
+	if not stages_variant is Array:
+		return
+	var nodes: Array[Node] = []
+	for stage_variant: Variant in stages_variant:
+		if not stage_variant is Dictionary:
+			continue
+		var stage: Dictionary = stage_variant
+		if str(stage.get("op", "")) not in ["add_node", "instantiate_scene", "duplicate_node"]:
+			continue
+		var node_variant: Variant = stage.get("node")
+		if not node_variant is Node:
+			continue
+		nodes.append(node_variant)
+	_discard_transaction_nodes(nodes)
+
+func _discard_transaction_nodes(nodes: Array[Node]) -> void:
+	var discarded: Dictionary = {}
+	for node: Node in nodes:
+		var instance_id: int = node.get_instance_id()
+		if discarded.has(instance_id):
+			continue
+		discarded[instance_id] = true
+		if is_instance_valid(node) and node.get_parent() == null:
+			node.free()
+
+func _validate_transaction(root: Node, operations: Array) -> Dictionary:
+	var allocated_nodes: Array[Node] = []
+	var validation: Dictionary = _validate_transaction_operations(root, operations, allocated_nodes)
+	if validation.has("error"):
+		_discard_transaction_nodes(allocated_nodes)
+	return validation
+
+func _validate_transaction_operations(root: Node, operations: Array, allocated_nodes: Array[Node]) -> Dictionary:
+	var stages: Array[Dictionary] = []
+	var virtual_nodes: Dictionary = {}
+	var virtual_paths: Dictionary = {}
+	var staged_node_ids: Dictionary = {}
+	_index_transaction_subtree(root, ".", virtual_nodes, virtual_paths)
+	var virtual_root_name: String = str(root.name)
+	var focus_path: String = ""
+	for index: int in operations.size():
+		var operation_variant: Variant = operations[index]
+		if not operation_variant is Dictionary:
+			return {"error": "invalid_operation", "operation_index": index}
+		var operation: Dictionary = operation_variant
+		var op: String = str(operation.get("op", ""))
+		if op == "save":
+			continue
+		if op == "add_node":
+			var parent_path: String = str(operation.get("parent_path", "."))
+			var parent: Node = _transaction_node(root, parent_path, virtual_nodes)
+			var node_type: String = str(operation.get("node_type", "Node"))
+			var node_name: String = str(operation.get("node_name", node_type)).strip_edges()
+			if parent == null: return {"error": "parent_not_found", "operation_index": index, "parent_path": parent_path}
+			if node_name.is_empty() or node_name.contains("/"): return {"error": "invalid_node_name", "operation_index": index}
+			var normalized_parent_path: String = str(virtual_paths.get(parent.get_instance_id(), ""))
+			var node_path: String = _joined_node_path(normalized_parent_path, node_name)
+			if virtual_nodes.has(node_path): return {"error": "duplicate_node_name", "operation_index": index, "node_name": node_name}
+			if not ClassDB.is_parent_class(node_type, "Node"): return {"error": "invalid_node_type", "operation_index": index, "node_type": node_type}
+			var node_variant: Variant = ClassDB.instantiate(node_type)
+			if not node_variant is Node: return {"error": "node_type_not_instantiable", "operation_index": index}
+			var node: Node = node_variant
+			allocated_nodes.append(node)
+			node.name = node_name
+			var properties_variant: Variant = operation.get("properties", {})
+			if not properties_variant is Dictionary: return {"error": "properties_must_be_object", "operation_index": index}
+			for property_name_variant: Variant in properties_variant:
+				var property_name: String = str(property_name_variant)
+				if not property_name in node: return {"error": "property_not_found", "operation_index": index, "property": property_name}
+				var decoded: Dictionary = _decode_editor_value(properties_variant[property_name_variant], node.get(property_name))
+				if decoded.has("error"): return {"error": decoded.error, "operation_index": index, "property": property_name}
+				node.set(property_name, decoded.value)
+			_index_transaction_subtree(node, node_path, virtual_nodes, virtual_paths, staged_node_ids, true)
+			stages.append({"op": op, "parent": parent, "node": node})
+			focus_path = node_path
+		elif op == "instantiate_scene":
+			var instance_parent_path: String = str(operation.get("parent_path", "."))
+			var instance_parent: Node = _transaction_node(root, instance_parent_path, virtual_nodes)
+			var packed_path: String = _resource_path(str(operation.get("scene_path", "")))
+			var packed: Resource = ResourceLoader.load(packed_path, "PackedScene")
+			if instance_parent == null or not packed is PackedScene:
+				return {"error": "packed_scene_or_parent_invalid", "operation_index": index}
+			var packed_scene: PackedScene = packed
+			var instance: Node = packed_scene.instantiate()
+			allocated_nodes.append(instance)
+			if operation.has("node_name"): instance.name = str(operation.node_name)
+			var instance_name: String = str(instance.name).strip_edges()
+			if instance_name.is_empty() or instance_name.contains("/"): return {"error": "invalid_node_name", "operation_index": index}
+			var normalized_instance_parent_path: String = str(virtual_paths.get(instance_parent.get_instance_id(), ""))
+			var instance_path: String = _joined_node_path(normalized_instance_parent_path, instance_name)
+			if virtual_nodes.has(instance_path): return {"error": "duplicate_node_name", "operation_index": index, "node_name": instance_name}
+			_index_transaction_subtree(instance, instance_path, virtual_nodes, virtual_paths, staged_node_ids, true)
+			stages.append({"op": op, "parent": instance_parent, "node": instance})
+			focus_path = instance_path
+		else:
+			var node_path: String = str(operation.get("node_path", "."))
+			var target: Node = _transaction_node(root, node_path, virtual_nodes)
+			if target == null: return {"error": "node_not_found", "operation_index": index, "node_path": node_path}
+			if target != root and target.owner != root and not staged_node_ids.has(target.get_instance_id()):
+				return {"error": "inherited_or_noneditable_node", "operation_index": index, "node_path": node_path}
+			var current_path: String = str(virtual_paths.get(target.get_instance_id(), ""))
+			if op == "remove_node":
+				if target == root: return {"error": "cannot_remove_scene_root", "operation_index": index}
+				var current_parent: Node = _transaction_node(root, current_path.get_base_dir(), virtual_nodes)
+				stages.append({"op": op, "node": target, "parent": current_parent, "index": target.get_index(), "owner": target.owner})
+				_remove_transaction_subtree(target, virtual_nodes, virtual_paths)
+			elif op == "rename_node":
+				var new_name: String = str(operation.get("name", operation.get("node_name", ""))).strip_edges()
+				if new_name.is_empty() or new_name.contains("/"): return {"error": "invalid_node_name", "operation_index": index}
+				var renamed_path: String = current_path if target == root else _joined_node_path(current_path.get_base_dir(), new_name)
+				if target != root and virtual_nodes.has(renamed_path) and virtual_nodes[renamed_path] != target:
+					return {"error": "duplicate_node_name", "operation_index": index, "node_name": new_name}
+				var before_name: String = virtual_root_name if target == root else current_path.get_file()
+				stages.append({"op": op, "node": target, "before": before_name, "after": new_name})
+				if target == root:
+					virtual_root_name = new_name
+				else:
+					_move_transaction_subtree(target, renamed_path, virtual_nodes, virtual_paths)
+				focus_path = renamed_path
+			elif op == "duplicate_node":
+				if target == root: return {"error": "cannot_duplicate_scene_root", "operation_index": index}
+				var duplicate_name: String = str(operation.get("node_name", "%sCopy" % current_path.get_file())).strip_edges()
+				if duplicate_name.is_empty() or duplicate_name.contains("/"): return {"error": "invalid_node_name", "operation_index": index}
+				var duplicate_path: String = _joined_node_path(current_path.get_base_dir(), duplicate_name)
+				if virtual_nodes.has(duplicate_path): return {"error": "duplicate_node_name", "operation_index": index, "node_name": duplicate_name}
+				var duplicated_node: Node = target.duplicate(Node.DUPLICATE_USE_INSTANTIATION)
+				allocated_nodes.append(duplicated_node)
+				duplicated_node.name = duplicate_name
+				var duplicate_parent: Node = _transaction_node(root, current_path.get_base_dir(), virtual_nodes)
+				_index_transaction_subtree(duplicated_node, duplicate_path, virtual_nodes, virtual_paths, staged_node_ids, true)
+				stages.append({"op": op, "node": duplicated_node, "parent": duplicate_parent})
+				focus_path = duplicate_path
+			elif op == "reparent_node":
+				if target == root: return {"error": "cannot_reparent_scene_root", "operation_index": index}
+				var new_parent_path: String = str(operation.get("new_parent_path", ""))
+				var new_parent: Node = _transaction_node(root, new_parent_path, virtual_nodes)
+				if new_parent == null: return {"error": "invalid_reparent_target", "operation_index": index}
+				var normalized_new_parent_path: String = str(virtual_paths.get(new_parent.get_instance_id(), ""))
+				if new_parent == target or normalized_new_parent_path.begins_with(current_path + "/"):
+					return {"error": "invalid_reparent_target", "operation_index": index}
+				var reparented_path: String = _joined_node_path(normalized_new_parent_path, current_path.get_file())
+				if virtual_nodes.has(reparented_path) and virtual_nodes[reparented_path] != target:
+					return {"error": "duplicate_node_name", "operation_index": index, "node_name": current_path.get_file()}
+				var before_parent: Node = _transaction_node(root, current_path.get_base_dir(), virtual_nodes)
+				stages.append({"op": op, "node": target, "before_parent": before_parent, "after_parent": new_parent, "keep_global": _variant_bool(operation.get("keep_global_transform", true))})
+				_move_transaction_subtree(target, reparented_path, virtual_nodes, virtual_paths)
+				focus_path = reparented_path
+			elif op == "set_properties":
+				var set_properties_variant: Variant = operation.get("properties", {})
+				if not set_properties_variant is Dictionary: return {"error": "properties_must_be_object", "operation_index": index}
+				for property_variant: Variant in set_properties_variant:
+					var property_name: String = str(property_variant)
+					if not property_name in target: return {"error": "property_not_found", "operation_index": index, "property": property_name}
+					var decoded: Dictionary = _decode_editor_value(set_properties_variant[property_variant], target.get(property_name))
+					if decoded.has("error"): return {"error": decoded.error, "operation_index": index, "property": property_name}
+					stages.append({"op": "set_property", "node": target, "property": property_name, "before": target.get(property_name), "after": decoded.value})
+				focus_path = current_path
+			elif op == "attach_script":
+				var script: Resource = ResourceLoader.load(_resource_path(str(operation.get("script_path", ""))), "Script")
+				if not script is Script: return {"error": "script_not_found", "operation_index": index}
+				stages.append({"op": "set_property", "node": target, "property": "script", "before": target.get_script(), "after": script})
+				focus_path = current_path
+			elif op == "assign_resource":
+				var resource_property: String = str(operation.get("property", ""))
+				var resource: Resource = ResourceLoader.load(_resource_path(str(operation.get("resource_path", ""))))
+				if resource_property.is_empty() or not resource_property in target or resource == null: return {"error": "resource_or_property_invalid", "operation_index": index}
+				stages.append({"op": "set_property", "node": target, "property": resource_property, "before": target.get(resource_property), "after": resource})
+				focus_path = current_path
+			else:
+				return {"error": "unsupported_operation", "operation_index": index, "op": op}
+	return {"stages": stages, "focus_path": focus_path}
+
+func _editor_resource_transaction(params: Dictionary) -> Dictionary:
+	if _driver_paused:
+		return {"error": "paused", "state": "paused"}
+	var resource_path: String = _resource_path(str(params.get("resource_path", "")))
+	var resource_type: String = str(params.get("resource_type", ""))
+	var properties_variant: Variant = params.get("properties", {})
+	if resource_path.is_empty() or not properties_variant is Dictionary:
+		return {"error": "resource_path and object properties are required"}
+	var properties: Dictionary = properties_variant
+	var resource: Resource
+	var created: bool = false
+	if ResourceLoader.exists(resource_path):
+		resource = ResourceLoader.load(resource_path)
+		if resource == null:
+			return {"error": "resource_load_failed", "resource_path": resource_path}
+	else:
+		if not _is_supported_editor_resource_type(resource_type):
+			return {"error": "unsupported_resource_type", "resource_type": resource_type}
+		var instance: Variant = ClassDB.instantiate(resource_type)
+		if not instance is Resource:
+			return {"error": "resource_type_not_instantiable", "resource_type": resource_type}
+		resource = instance
+		created = true
+	var stages: Array[Dictionary] = []
+	for property_variant: Variant in properties:
+		var property_name: String = str(property_variant)
+		if not property_name in resource:
+			return {"error": "property_not_found", "property": property_name}
+		var decoded: Dictionary = _decode_editor_value(properties[property_variant], resource.get(property_name))
+		if decoded.has("error"):
+			return {"error": decoded.error, "property": property_name}
+		stages.append({"property": property_name, "before": resource.get(property_name), "after": decoded.value})
+	var undo_recorded: bool = not created and not stages.is_empty()
+	if undo_recorded:
+		var manager: EditorUndoRedoManager = EditorInterface.get_editor_undo_redo()
+		if manager == null:
+			return {"error": "undo_redo_unavailable"}
+		manager.create_action(str(params.get("name", "Modify resource")))
+		for stage: Dictionary in stages:
+			var property_name: StringName = StringName(str(stage.get("property", "")))
+			manager.add_do_property(resource, property_name, stage.get("after"))
+			manager.add_undo_property(resource, property_name, stage.get("before"))
+		manager.commit_action()
+		_last_history_id = manager.get_object_history_id(resource)
+	else:
+		for stage: Dictionary in stages:
+			var property_name: StringName = StringName(str(stage.get("property", "")))
+			resource.set(property_name, stage.get("after"))
+	var directory_error: Error = _ensure_resource_parent_directory(resource_path)
+	if directory_error != OK:
+		return {"error": "resource_directory_failed", "error_code": directory_error, "undo_recorded": undo_recorded}
+	var save_error: Error = ResourceSaver.save(resource, resource_path)
+	if save_error != OK:
+		return {"error": "resource_save_failed", "error_code": save_error, "undo_recorded": undo_recorded}
+	EditorInterface.edit_resource(resource)
+	var readback: Resource = ResourceLoader.load(resource_path, "", ResourceLoader.CACHE_MODE_IGNORE)
+	if readback == null:
+		return {"error": "independent_resource_readback_failed", "undo_recorded": undo_recorded}
+	var observed_properties: Dictionary = {}
+	for property_variant: Variant in properties:
+		var property_name: String = str(property_variant)
+		observed_properties[property_name] = str(readback.get(property_name))
+	return {
+		"success": true,
+		"backend": "editor",
+		"resource_path": resource_path,
+		"resource_type": readback.get_class(),
+		"resource_uid": ResourceLoader.get_resource_uid(resource_path),
+		"created": created,
+		"undo_recorded": undo_recorded,
+		"creation_fallback": _creation_fallback(created, "initial ResourceSaver save required before editor inspection"),
+		"focused": true,
+		"observed_target_state": {
+			"resource_path": resource_path,
+			"resource_type": readback.get_class(),
+			"properties": observed_properties,
+			"independently_reloaded": true,
+		},
+	}
+
+func _is_supported_editor_resource_type(resource_type: String) -> bool:
+	if resource_type.is_empty() or not ClassDB.class_exists(resource_type) or not ClassDB.can_instantiate(resource_type):
+		return false
+	for base_type: String in ["BaseMaterial3D", "Mesh", "Shape2D", "Shape3D", "Theme", "AudioStream", "Gradient", "Curve", "Environment"]:
+		if ClassDB.is_parent_class(resource_type, base_type):
+			return true
+	return false
+
+func _apply_transaction_stage(manager: EditorUndoRedoManager, root: Node, stage: Dictionary) -> void:
+	var op: String = str(stage.get("op", ""))
+	var stage_node_variant: Variant = stage.get("node")
+	if not stage_node_variant is Node:
+		return
+	var stage_node: Node = stage_node_variant
+	if op in ["add_node", "instantiate_scene", "duplicate_node"]:
+		var parent_variant: Variant = stage.get("parent")
+		if not parent_variant is Node:
+			return
+		var parent: Node = parent_variant
+		manager.add_do_method(parent, "add_child", stage_node, true)
+		manager.add_do_method(self, "_set_scene_owner_recursive", stage_node, root)
+		manager.add_do_reference(stage_node)
+		manager.add_undo_method(parent, "remove_child", stage_node)
+	elif op == "remove_node":
+		var parent_variant: Variant = stage.get("parent")
+		if not parent_variant is Node:
+			return
+		var parent: Node = parent_variant
+		manager.add_do_method(parent, "remove_child", stage_node)
+		manager.add_undo_method(parent, "add_child", stage_node, true)
+		manager.add_undo_method(parent, "move_child", stage_node, _variant_int(stage.get("index", 0)))
+		manager.add_undo_property(stage_node, "owner", stage.get("owner"))
+	elif op == "rename_node":
+		manager.add_do_property(stage_node, "name", stage.get("after"))
+		manager.add_undo_property(stage_node, "name", stage.get("before"))
+	elif op == "reparent_node":
+		var after_parent_variant: Variant = stage.get("after_parent")
+		var before_parent_variant: Variant = stage.get("before_parent")
+		if not after_parent_variant is Node or not before_parent_variant is Node:
+			return
+		var after_parent: Node = after_parent_variant
+		var before_parent: Node = before_parent_variant
+		var keep_global: bool = _variant_bool(stage.get("keep_global", true))
+		manager.add_do_method(stage_node, "reparent", after_parent, keep_global)
+		manager.add_undo_method(stage_node, "reparent", before_parent, keep_global)
+	elif op == "set_property":
+		var property_name: StringName = StringName(str(stage.get("property", "")))
+		manager.add_do_property(stage_node, property_name, stage.get("after"))
+		manager.add_undo_property(stage_node, property_name, stage.get("before"))
+
+func _set_scene_owner_recursive(node: Node, scene_owner: Node) -> void:
+	node.owner = scene_owner
+	for child: Node in node.get_children(true):
+		_set_scene_owner_recursive(child, scene_owner)
+
+func _transaction_node(root: Node, path: String, staged_nodes: Dictionary) -> Node:
+	var normalized: String = _normalize_transaction_path(path)
+	if normalized == ".": return root
+	if staged_nodes.has(normalized): return staged_nodes[normalized]
+	return null
+
+func _normalize_transaction_path(path: String) -> String:
+	var normalized: String = path.strip_edges().trim_prefix("root/").trim_prefix("./").trim_suffix("/")
+	return "." if normalized in ["", ".", "root"] else normalized
+
+func _index_transaction_subtree(
+	node: Node,
+	path: String,
+	virtual_nodes: Dictionary,
+	virtual_paths: Dictionary,
+	staged_node_ids: Dictionary = {},
+	mark_staged: bool = false,
+) -> void:
+	var normalized_path: String = _normalize_transaction_path(path)
+	virtual_nodes[normalized_path] = node
+	virtual_paths[node.get_instance_id()] = normalized_path
+	if mark_staged:
+		staged_node_ids[node.get_instance_id()] = true
+	for child: Node in node.get_children():
+		_index_transaction_subtree(child, _joined_node_path(normalized_path, str(child.name)), virtual_nodes, virtual_paths, staged_node_ids, mark_staged)
+
+func _remove_transaction_subtree(node: Node, virtual_nodes: Dictionary, virtual_paths: Dictionary) -> void:
+	var root_path: String = str(virtual_paths.get(node.get_instance_id(), ""))
+	if root_path.is_empty():
+		return
+	for path_variant: Variant in virtual_nodes.keys():
+		var path: String = str(path_variant)
+		if path == root_path or path.begins_with(root_path + "/"):
+			var removed_node_variant: Variant = virtual_nodes.get(path)
+			if removed_node_variant is Node:
+				var removed_node: Node = removed_node_variant
+				@warning_ignore("return_value_discarded")
+				virtual_paths.erase(removed_node.get_instance_id())
+			@warning_ignore("return_value_discarded")
+			virtual_nodes.erase(path)
+
+func _move_transaction_subtree(node: Node, new_path: String, virtual_nodes: Dictionary, virtual_paths: Dictionary) -> void:
+	var old_path: String = str(virtual_paths.get(node.get_instance_id(), ""))
+	var normalized_new_path: String = _normalize_transaction_path(new_path)
+	if old_path.is_empty() or old_path == normalized_new_path:
+		return
+	var moved_nodes: Array[Dictionary] = []
+	for path_variant: Variant in virtual_nodes.keys():
+		var path: String = str(path_variant)
+		if path == old_path or path.begins_with(old_path + "/"):
+			var moved_node_variant: Variant = virtual_nodes.get(path)
+			if moved_node_variant is Node:
+				var suffix: String = path.trim_prefix(old_path)
+				moved_nodes.append({"node": moved_node_variant, "path": normalized_new_path + suffix})
+			@warning_ignore("return_value_discarded")
+			virtual_nodes.erase(path)
+	for moved: Dictionary in moved_nodes:
+		var moved_node: Node = moved.node
+		var moved_path: String = str(moved.path)
+		virtual_nodes[moved_path] = moved_node
+		virtual_paths[moved_node.get_instance_id()] = moved_path
+
+func _joined_node_path(parent_path: String, node_name: String) -> String:
+	var normalized: String = _normalize_transaction_path(parent_path)
+	return node_name if normalized in ["", ".", "root"] else normalized.path_join(node_name)
+
+func _resource_path(path: String) -> String:
+	return path if path.begins_with("res://") else "res://" + path.trim_prefix("/")
+
+func _ensure_resource_parent_directory(resource_path: String) -> Error:
+	var parent: String = resource_path.get_base_dir()
+	if parent in ["", "res://"]:
+		return OK
+	return DirAccess.make_dir_recursive_absolute(ProjectSettings.globalize_path(parent))
+
+func _decode_editor_value(value: Variant, current: Variant) -> Dictionary:
+	if value is Dictionary:
+		var typed: Dictionary = value
+		if not typed.has("type"):
+			return _decode_untyped_editor_value(typed, current)
+		var type_name: String = str(typed.get("type", ""))
+		var data: Variant = typed.get("value")
+		var data_array: Array = data if data is Array else []
+		if type_name == "Vector2" and data_array.size() == 2: return {"value": Vector2(_variant_float(data_array[0]), _variant_float(data_array[1]))}
+		if type_name == "Vector2i" and data_array.size() == 2: return {"value": Vector2i(_variant_int(data_array[0]), _variant_int(data_array[1]))}
+		if type_name == "Vector3" and data_array.size() == 3: return {"value": Vector3(_variant_float(data_array[0]), _variant_float(data_array[1]), _variant_float(data_array[2]))}
+		if type_name == "Vector3i" and data_array.size() == 3: return {"value": Vector3i(_variant_int(data_array[0]), _variant_int(data_array[1]), _variant_int(data_array[2]))}
+		if type_name == "Color": return {"value": Color(str(data))}
+		if type_name == "NodePath": return {"value": NodePath(str(data))}
+		if type_name == "StringName": return {"value": StringName(str(data))}
+		if type_name == "Resource":
+			var resource: Resource = ResourceLoader.load(_resource_path(str(data)))
+			return {"error": "resource_not_found"} if resource == null else {"value": resource}
+		return {"error": "unsupported_typed_value"}
+	match typeof(current):
+		TYPE_INT: return {"value": _variant_int(value)}
+		TYPE_FLOAT: return {"value": _variant_float(value)}
+		TYPE_BOOL: return {"value": _variant_bool(value)}
+		TYPE_STRING: return {"value": str(value)}
+		TYPE_STRING_NAME: return {"value": StringName(str(value))}
+		TYPE_NODE_PATH: return {"value": NodePath(str(value))}
+		TYPE_OBJECT:
+			if current is Resource and value is String:
+				var referenced: Resource = ResourceLoader.load(_resource_path(str(value)))
+				return {"error": "resource_not_found"} if referenced == null else {"value": referenced}
+	return {"value": value}
+
+func _decode_untyped_editor_value(value: Dictionary, current: Variant) -> Dictionary:
+	match typeof(current):
+		TYPE_VECTOR2:
+			if value.has("x") and value.has("y"): return {"value": Vector2(_variant_float(value.get("x")), _variant_float(value.get("y")))}
+		TYPE_VECTOR2I:
+			if value.has("x") and value.has("y"): return {"value": Vector2i(_variant_int(value.get("x")), _variant_int(value.get("y")))}
+		TYPE_VECTOR3:
+			if value.has("x") and value.has("y") and value.has("z"): return {"value": Vector3(_variant_float(value.get("x")), _variant_float(value.get("y")), _variant_float(value.get("z")))}
+		TYPE_VECTOR3I:
+			if value.has("x") and value.has("y") and value.has("z"): return {"value": Vector3i(_variant_int(value.get("x")), _variant_int(value.get("y")), _variant_int(value.get("z")))}
+		TYPE_COLOR:
+			if value.has("r") and value.has("g") and value.has("b"): return {"value": Color(_variant_float(value.get("r")), _variant_float(value.get("g")), _variant_float(value.get("b")), _variant_float(value.get("a", 1.0)))}
+	return {"value": value}
+
+func _independent_scene_readback(scene_path: String) -> Dictionary:
+	var packed: Resource = ResourceLoader.load(scene_path, "PackedScene", ResourceLoader.CACHE_MODE_IGNORE)
+	if not packed is PackedScene:
+		return {"error": "packed_scene_reload_failed"}
+	var packed_scene: PackedScene = packed
+	var instance: Node = packed_scene.instantiate()
+	if instance == null:
+		return {"error": "packed_scene_instantiate_failed"}
+	var node_count: int = _count_scene_nodes(instance)
+	var hierarchy: Array[String] = []
+	_collect_scene_paths(instance, instance, hierarchy, 256)
+	var result: Dictionary = {
+		"scene_path": scene_path,
+		"root_name": str(instance.name),
+		"root_type": instance.get_class(),
+		"node_count": node_count,
+		"hierarchy": hierarchy,
+		"independently_reopened": true,
+	}
+	instance.free()
+	return result
+
+func _count_scene_nodes(node: Node) -> int:
+	var count: int = 1
+	for child: Node in node.get_children(): count += _count_scene_nodes(child)
+	return count
+
+func _collect_scene_paths(root: Node, node: Node, paths: Array[String], limit: int) -> void:
+	if paths.size() >= limit: return
+	paths.append("." if node == root else str(root.get_path_to(node)))
+	for child: Node in node.get_children(): _collect_scene_paths(root, child, paths, limit)
+
 func _send(response: Dictionary) -> void:
 	if _peer == null:
 		return
@@ -415,3 +1116,117 @@ func _read_port() -> int:
 		var value: int = int(configured)
 		if value > 0 and value < 65536: return value
 	return _port
+
+func _on_scene_changed(scene_root: Node) -> void:
+	if scene_root != null and not scene_root.scene_file_path.is_empty():
+		_saved_history_versions[scene_root.scene_file_path] = _history_version(scene_root)
+
+func _on_scene_saved(filepath: String) -> void:
+	var root: Node = EditorInterface.get_edited_scene_root()
+	if root != null and root.scene_file_path == filepath:
+		_saved_history_versions[filepath] = _history_version(root)
+
+func _history_version(root: Node) -> int:
+	var manager: EditorUndoRedoManager = EditorInterface.get_editor_undo_redo()
+	if manager == null:
+		return 0
+	var history_id: int = manager.get_object_history_id(root)
+	var history: UndoRedo = manager.get_history_undo_redo(history_id)
+	return 0 if history == null else history.get_version()
+
+func _scene_has_unsaved_changes(root: Node) -> bool:
+	var path: String = root.scene_file_path
+	if path.is_empty():
+		return true
+	var current_version: int = _history_version(root)
+	if not _saved_history_versions.has(path):
+		_saved_history_versions[path] = current_version
+		return false
+	return _variant_int(_saved_history_versions[path]) != current_version
+
+func _variant_int(value: Variant) -> int:
+	if value is int:
+		return value
+	if value is float:
+		var float_value: float = value
+		return roundi(float_value)
+	if value is bool:
+		return 1 if value else 0
+	return 0
+
+func _variant_float(value: Variant) -> float:
+	if value is float:
+		return value
+	if value is int:
+		var int_value: int = value
+		return float(int_value)
+	if value is bool:
+		return 1.0 if value else 0.0
+	return 0.0
+
+func _variant_bool(value: Variant) -> bool:
+	if value is bool:
+		return value
+	if value is int:
+		return value != 0
+	if value is float:
+		var float_value: float = value
+		return not is_zero_approx(float_value)
+	return false
+
+func _creation_fallback(created: bool, message: String) -> Variant:
+	if created:
+		return message
+	return null
+
+func _write_discovery_record() -> Error:
+	var directory: String = _project_path.path_join(SESSION_DIRECTORY)
+	var directory_error: Error = DirAccess.make_dir_recursive_absolute(directory)
+	if directory_error != OK:
+		return directory_error
+	var record: Dictionary = {
+		"project_path": _project_path,
+		"editor_pid": _editor_pid,
+		"editor_start_identity": _editor_start_identity,
+		"port": _port,
+		"token": _secret,
+		"protocol_version": PROTOCOL_VERSION,
+		"addon_version": ADDON_VERSION,
+		"godot_version": str(Engine.get_version_info().get("string", "unknown")),
+		"created_at": str(Time.get_unix_time_from_system()),
+	}
+	var temporary_path: String = _session_path + ".tmp-%d" % _editor_pid
+	var file: FileAccess = FileAccess.open(temporary_path, FileAccess.WRITE)
+	if file == null:
+		return FileAccess.get_open_error()
+	@warning_ignore("return_value_discarded")
+	file.store_string(JSON.stringify(record) + "\n")
+	file.flush()
+	file.close()
+	var permission_error: Error = FileAccess.set_unix_permissions(temporary_path, 384)
+	if permission_error != OK and OS.get_name() not in ["Windows", "Web"]:
+		@warning_ignore("return_value_discarded")
+		DirAccess.remove_absolute(temporary_path)
+		return permission_error
+	if FileAccess.file_exists(_session_path):
+		@warning_ignore("return_value_discarded")
+		DirAccess.remove_absolute(_session_path)
+	var rename_error: Error = DirAccess.rename_absolute(temporary_path, _session_path)
+	if rename_error != OK:
+		@warning_ignore("return_value_discarded")
+		DirAccess.remove_absolute(temporary_path)
+	return rename_error
+
+func _remove_owned_discovery_record() -> void:
+	if _session_path.is_empty() or not FileAccess.file_exists(_session_path):
+		return
+	var file: FileAccess = FileAccess.open(_session_path, FileAccess.READ)
+	if file == null:
+		return
+	var parsed: Variant = JSON.parse_string(file.get_as_text())
+	file.close()
+	var parsed_record: Dictionary = parsed if parsed is Dictionary else {}
+	if not parsed_record.is_empty() and str(parsed_record.get("editor_start_identity", "")) == _editor_start_identity:
+		var remove_error: Error = DirAccess.remove_absolute(_session_path)
+		if remove_error != OK:
+			push_warning("Godot Agent Loop could not remove editor discovery record: %s" % error_string(remove_error))