From 64427aec1b43b19ea01acb0e892e19464096a82a Mon Sep 17 00:00:00 2001
From: Virgil <virgil@lethean.io>
Date: Mon, 30 Mar 2026 22:45:15 +0000
Subject: [PATCH] refactor(ax): add semantic workspace message handler

---
 workspace/service.go      | 25 +++++++++++++++++++------
 workspace/service_test.go | 31 +++++++++++++++++++++++--------
 2 files changed, 42 insertions(+), 14 deletions(-)

diff --git a/workspace/service.go b/workspace/service.go
index efe2269..22681ba 100644
--- a/workspace/service.go
+++ b/workspace/service.go
@@ -195,21 +195,34 @@ func (service *Service) HandleWorkspaceCommand(command WorkspaceCommand) core.Re
 	return core.Result{OK: true}
 }
 
-// Example: result := service.HandleIPCEvents(core.New(), map[string]any{"action": WorkspaceSwitchAction, "workspaceID": "f3f0d7"})
-// HandleIPCEvents preserves the legacy map[string]any payload and still accepts WorkspaceCommand values.
-func (service *Service) HandleIPCEvents(_ *core.Core, message core.Message) core.Result {
+// Example: result := service.HandleWorkspaceMessage(core.New(), WorkspaceCommand{Action: WorkspaceSwitchAction, WorkspaceID: "f3f0d7"})
+// Example: legacy := service.HandleWorkspaceMessage(core.New(), map[string]any{"action": WorkspaceCreateAction, "identifier": "alice", "password": "pass123"})
+func (service *Service) HandleWorkspaceMessage(_ *core.Core, message core.Message) core.Result {
+	command, ok := workspaceCommandFromMessage(message)
+	if !ok {
+		return core.Result{OK: true}
+	}
+	return service.HandleWorkspaceCommand(command)
+}
+
+// Example: result := service.HandleIPCEvents(core.New(), WorkspaceCommand{Action: WorkspaceSwitchAction, WorkspaceID: "f3f0d7"})
+func (service *Service) HandleIPCEvents(coreRuntime *core.Core, message core.Message) core.Result {
+	return service.HandleWorkspaceMessage(coreRuntime, message)
+}
+
+func workspaceCommandFromMessage(message core.Message) (WorkspaceCommand, bool) {
 	switch payload := message.(type) {
 	case WorkspaceCommand:
-		return service.HandleWorkspaceCommand(payload)
+		return payload, true
 	case map[string]any:
 		command := WorkspaceCommand{}
 		command.Action, _ = payload["action"].(string)
 		command.Identifier, _ = payload["identifier"].(string)
 		command.Password, _ = payload["password"].(string)
 		command.WorkspaceID, _ = payload["workspaceID"].(string)
-		return service.HandleWorkspaceCommand(command)
+		return command, true
 	}
-	return core.Result{OK: true}
+	return WorkspaceCommand{}, false
 }
 
 func resolveWorkspaceHomeDirectory() string {
diff --git a/workspace/service_test.go b/workspace/service_test.go
index 13c65b0..31ddf94 100644
--- a/workspace/service_test.go
+++ b/workspace/service_test.go
@@ -93,10 +93,10 @@ func TestService_WorkspaceFileSet_TraversalBlocked_Bad(t *testing.T) {
 	require.Error(t, err)
 }
 
-func TestService_HandleWorkspaceCommand_Good(t *testing.T) {
+func TestService_HandleWorkspaceMessage_Good(t *testing.T) {
 	s, _ := newTestService(t)
 
-	create := s.HandleWorkspaceCommand(WorkspaceCommand{
+	create := s.HandleWorkspaceMessage(core.New(), WorkspaceCommand{
 		Action:     WorkspaceCreateAction,
 		Identifier: "ipc-user",
 		Password:   "pass123",
@@ -107,14 +107,14 @@ func TestService_HandleWorkspaceCommand_Good(t *testing.T) {
 	require.True(t, ok)
 	require.NotEmpty(t, workspaceID)
 
-	switchResult := s.HandleWorkspaceCommand(WorkspaceCommand{
+	switchResult := s.HandleWorkspaceMessage(core.New(), WorkspaceCommand{
 		Action:      WorkspaceSwitchAction,
 		WorkspaceID: workspaceID,
 	})
 	assert.True(t, switchResult.OK)
 	assert.Equal(t, workspaceID, s.activeWorkspaceID)
 
-	legacyCreate := s.HandleIPCEvents(core.New(), map[string]any{
+	legacyCreate := s.HandleWorkspaceMessage(core.New(), map[string]any{
 		"action":     WorkspaceCreateAction,
 		"identifier": "legacy-user",
 		"password":   "pass123",
@@ -125,26 +125,41 @@ func TestService_HandleWorkspaceCommand_Good(t *testing.T) {
 	require.True(t, ok)
 	require.NotEmpty(t, legacyWorkspaceID)
 
-	legacySwitch := s.HandleIPCEvents(core.New(), WorkspaceCommand{
+	legacySwitch := s.HandleWorkspaceMessage(core.New(), WorkspaceCommand{
 		Action:      WorkspaceSwitchAction,
 		WorkspaceID: legacyWorkspaceID,
 	})
 	assert.True(t, legacySwitch.OK)
 	assert.Equal(t, legacyWorkspaceID, s.activeWorkspaceID)
 
-	rejectedLegacySwitch := s.HandleIPCEvents(core.New(), map[string]any{
+	rejectedLegacySwitch := s.HandleWorkspaceMessage(core.New(), map[string]any{
 		"action": WorkspaceSwitchAction,
 		"name":   workspaceID,
 	})
 	assert.False(t, rejectedLegacySwitch.OK)
 	assert.Equal(t, legacyWorkspaceID, s.activeWorkspaceID)
 
-	failedSwitch := s.HandleIPCEvents(core.New(), map[string]any{
+	failedSwitch := s.HandleWorkspaceMessage(core.New(), map[string]any{
 		"action":      WorkspaceSwitchAction,
 		"workspaceID": "missing",
 	})
 	assert.False(t, failedSwitch.OK)
 
-	unknown := s.HandleIPCEvents(core.New(), "noop")
+	unknown := s.HandleWorkspaceMessage(core.New(), "noop")
 	assert.True(t, unknown.OK)
 }
+
+func TestService_HandleIPCEvents_Compatibility_Good(t *testing.T) {
+	s, _ := newTestService(t)
+
+	result := s.HandleIPCEvents(core.New(), WorkspaceCommand{
+		Action:     WorkspaceCreateAction,
+		Identifier: "compat-user",
+		Password:   "pass123",
+	})
+
+	assert.True(t, result.OK)
+	workspaceID, ok := result.Value.(string)
+	require.True(t, ok)
+	require.NotEmpty(t, workspaceID)
+}