fix: live-sync completeness -- run lifecycle emits + hotkey/keybinding vocabulary (goal 0057) (#113)

* fix: live-sync completeness -- run lifecycle emits + hotkey/keybinding entity vocabulary (goal 0057)

Closes the three run-lifecycle emit gaps (ResolveApproval, CancelRun's
ENQUEUED path, RedriveRun's fork path) and adds the missing "hotkey"/
"keybinding" dataevent entities so hotkey and command-keybinding
mutations emit mill-data-changed, with live subscriptions added to
every verified fetch-once frontend surface (CommandPalette, QuickPanel,
hotkeyCapture.ts's useComboCapture, App.tsx's central router).

* test: mcpsvc emit coverage completes goal 0057 box 3

* test: seed-lifecycle + AI-provider emit coverage -- goal 0057 box 3 complete

Author: alicoding

frontend/src/app/App.tsx

@@ -253,6 +253,7 @@ function App() {
       if (entity === 'decision') void refreshDecisions()
       if (entity === 'execenv') void refreshExecEnvs()
       if (entity === 'aiprovider') void refreshAIProviders()
+      if (entity === 'keybinding') void refreshKeybindings()
     })
   }, [])
 

frontend/src/app/CommandPalette.tsx

@@ -4,6 +4,7 @@ import { useTranslation } from 'react-i18next'
 import { Dialog, Text } from '@primer/react'
 import { FilteredActionList } from '@primer/react/experimental'
 import { CommandPaletteIcon, PencilIcon, PlayIcon, TabIcon, XIcon } from '@primer/octicons-react'
+import { Events } from '@wailsio/runtime'
 import { ExecutionService, RunKind, TriggerService } from '../shared/bindings'
 import { COMMANDS } from '../shared/commands'
 import { generateSamplePayload } from '../shared/configSchema'
@@ -149,6 +150,17 @@ export function CommandPalette() {
     TriggerService.ListHotkeys().then((combos) => setHotkeyCombos(combos ?? {})).catch(() => {})
   }, [paletteOpen])
 
+  // Live sync while the palette stays open: a hotkey assigned/cleared
+  // elsewhere (Composition's NodeInspector, another open tab) refreshes
+  // the inline combo hints without waiting for the palette to be
+  // closed and reopened.
+  useEffect(() => {
+    return Events.On('mill-data-changed', (evt) => {
+      const entity = (evt.data as { entity?: string })?.entity
+      if (entity === 'hotkey') TriggerService.ListHotkeys().then((combos) => setHotkeyCombos(combos ?? {})).catch(() => {})
+    })
+  }, [])
+
   // Runs a workflow through the exact same RPC + RunKind CompositionView's
   // own list-row Run button uses (ExecutionService.RunWorkflow,
   // RunKind.RunKindTest -- docs/adr/0008's single execution path), and

frontend/src/app/QuickPanel.tsx

@@ -191,8 +191,11 @@ export function QuickPanel() {
   // this window happens to be open updates the jump rows without
   // waiting for the next show. Scoped to just the entity kinds this
   // panel actually renders (workflow/run for frecency+the row list,
-  // request/list/mcpserver for the Configure jump rows); 'run' also
-  // refreshes frecency since a new run changes MostUsed's ranking.
+  // request/list/mcpserver for the Configure jump rows, hotkey/
+  // keybinding for the inline combo hints); 'run' also refreshes
+  // frecency since a new run changes MostUsed's ranking. hotkey/
+  // keybinding are ALSO refetched on every show (focusAndReset above)
+  // -- this closes the gap while the panel stays open between shows.
   useEffect(() => {
     return Events.On('mill-data-changed', (evt) => {
       const entity = (evt.data as { entity?: string })?.entity
@@ -201,6 +204,8 @@ export function QuickPanel() {
       if (entity === 'request') void refreshRequests()
       if (entity === 'list') void refreshLists()
       if (entity === 'mcpserver') void refreshMCPServers()
+      if (entity === 'hotkey') refreshHotkeyCombos()
+      if (entity === 'keybinding') void refreshKeybindings()
     })
   }, [])
 

frontend/src/composition/hotkeyCapture.ts

@@ -1,5 +1,6 @@
 import { useEffect, useMemo, useState } from 'react'
 import { useTranslation } from 'react-i18next'
+import { Events } from '@wailsio/runtime'
 import { SettingsService, TriggerService } from '../shared/bindings'
 import { comboKey, describeCombo, formatCombo, keyFromEventCode, modsFromEvent, reservedByMacOS } from '../shared/keybinding'
 import { refreshKeybindings, useAppStore } from '../shared/store'
@@ -29,6 +30,12 @@ interface ComboCaptureAdapter {
   currentBinding: () => Promise<string | null>
   assign: (mods: string[], key: string) => Promise<string>
   unassign: () => Promise<void>
+  // Which mill-data-changed entity carries this adapter's own combo --
+  // "hotkey" (a workflow trigger) or "keybinding" (a command override).
+  // Lets useComboCapture refetch currentBinding when the SAME target
+  // changes from elsewhere (another open tab/window's recorder), not
+  // just after this hook instance's own assign/unassign call.
+  entity: 'hotkey' | 'keybinding'
 }
 
 // Extracted from the now-retired RunbookView.tsx (docs/SPEC.md §2.2's
@@ -58,6 +65,21 @@ function useComboCapture(enabled: boolean, adapter: ComboCaptureAdapter, onChang
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [enabled])
 
+  // Live sync: this target's combo can change from a DIFFERENT open
+  // recorder instance (another tab's NodeInspector, the Settings
+  // Keyboard Shortcuts row, a second window) -- without this, only the
+  // instance that made the change saw its own onChanged callback, and
+  // every other mounted recorder for the same target stayed on its
+  // mount-time snapshot until closed and reopened.
+  useEffect(() => {
+    if (!enabled) return
+    return Events.On('mill-data-changed', (evt) => {
+      const changed = (evt.data as { entity?: string })?.entity
+      if (changed === adapter.entity) adapter.currentBinding().then(setBinding).catch(console.error)
+    })
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [enabled])
+
   // Menu-accelerator suspension (SettingsService.SuspendMenuAccelerators)
   // brackets the entire time this hook is "recording", not just the
   // keydown listener below -- on macOS, NSMenu's own
@@ -148,6 +170,7 @@ export function useHotkeyCapture(workflowId: string | null, onChanged?: () => vo
     currentBinding: () => TriggerService.ListHotkeys().then((list) => (list ?? {})[workflowId ?? ''] ?? null),
     assign: (mods, key) => TriggerService.AssignHotkey(workflowId ?? '', mods, key),
     unassign: () => TriggerService.UnassignHotkey(workflowId ?? ''),
+    entity: 'hotkey',
   }), [workflowId])
   return useComboCapture(workflowId !== null, adapter, onChanged)
 }
@@ -199,6 +222,7 @@ export function useCommandKeybindingCapture(commandId: string | null, onChanged?
       })
     },
     unassign: () => SettingsService.ClearKeybinding(commandId ?? '').then(() => { void refreshKeybindings() }),
+    entity: 'keybinding',
   }), [commandId, t])
   return useComboCapture(commandId !== null, adapter, onChanged)
 }

internal/services/compositionsvc/compositionservice_dataevent_test.go

@@ -136,6 +136,46 @@ func TestDataEvent_WorkflowMutations(t *testing.T) {
 	})
 }
 
+// TestDataEvent_SeedLifecycleMutations proves goal 0017's P0-2 for
+// ResetWorkflowToSeed/RestoreWorkflow (compositionservice_seedlifecycle.go,
+// docs/goals/0037 items 4/5) -- both bypass the mutateWorkflow choke
+// point TestDataEvent_WorkflowMutations' other subtests all route
+// through, so they need their own direct emit coverage. Reuses
+// firstGoldenID/the golden-workflow fixture
+// compositionservice_seedlifecycle_test.go's own Reset/Restore tests
+// already establish.
+func TestDataEvent_SeedLifecycleMutations(t *testing.T) {
+	t.Run("ResetWorkflowToSeed", func(t *testing.T) {
+		c := NewCompositionService(servicetest.NewFakeStore())
+		id := firstGoldenID(t)
+		if _, err := c.UpdateWorkflow(id, "User's own edit", "", []composition.Node{{ID: "t", NodeTypeID: "trigger-manual"}}, nil); err != nil {
+			t.Fatalf("UpdateWorkflow: %v", err)
+		}
+
+		got := captureEmits(t)
+		reset, err := c.ResetWorkflowToSeed(id)
+		if err != nil {
+			t.Fatalf("ResetWorkflowToSeed: %v", err)
+		}
+		assertEmittedWorkflow(t, *got, reset.ID)
+	})
+
+	t.Run("RestoreWorkflow", func(t *testing.T) {
+		c := NewCompositionService(servicetest.NewFakeStore())
+		id := firstGoldenID(t)
+		if err := c.DeleteWorkflow(id); err != nil {
+			t.Fatalf("DeleteWorkflow: %v", err)
+		}
+
+		got := captureEmits(t)
+		restored, err := c.RestoreWorkflow(id)
+		if err != nil {
+			t.Fatalf("RestoreWorkflow: %v", err)
+		}
+		assertEmittedWorkflow(t, *got, restored.ID)
+	})
+}
+
 // assertEmittedWorkflow fails the test unless got contains at least
 // one dataevent.Changed{"workflow", id} pair -- every mutation this
 // file tests emits the "workflow" entity, so entity itself isn't a

internal/services/configuresvc/configureservice_dataevent_test.go

@@ -3,6 +3,7 @@ package configuresvc
 import (
 	"testing"
 
+	"github.com/alicoding/mill/internal/domain/aiprovider"
 	"github.com/alicoding/mill/internal/domain/composition"
 	"github.com/alicoding/mill/internal/domain/decision"
 	"github.com/alicoding/mill/internal/domain/execenv"
@@ -191,6 +192,33 @@ func TestDataEvent_ExecEnvMutations(t *testing.T) {
 	assertEmitted(t, *got, "execenv", e.ID)
 }
 
+// TestDataEvent_AIProviderMutations proves goal 0017's P0-2 for AI
+// Providers -- "aiprovider" is a NEW entity string on the wire
+// (goal 0031's AI node family).
+func TestDataEvent_AIProviderMutations(t *testing.T) {
+	cfg, _ := newTestConfigureService(t)
+
+	got := captureEmits(t)
+	p, err := cfg.CreateAIProvider("Emit test provider", aiprovider.KindAnthropic, "", "claude")
+	if err != nil {
+		t.Fatalf("CreateAIProvider: %v", err)
+	}
+	assertEmitted(t, *got, "aiprovider", p.ID)
+
+	got = captureEmits(t)
+	p, err = cfg.UpdateAIProvider(p.ID, "Emit test provider (edited)", aiprovider.KindAnthropic, "", "claude")
+	if err != nil {
+		t.Fatalf("UpdateAIProvider: %v", err)
+	}
+	assertEmitted(t, *got, "aiprovider", p.ID)
+
+	got = captureEmits(t)
+	if err := cfg.DeleteAIProvider(p.ID); err != nil {
+		t.Fatalf("DeleteAIProvider: %v", err)
+	}
+	assertEmitted(t, *got, "aiprovider", p.ID)
+}
+
 // TestDataEvent_UpdateWorkflowAttributes_DelegatesToComposition proves
 // goal 0017's "workflow-attributes changes" item: ConfigureService's
 // delegate emits "workflow" via CompositionService.UpdateAttributes,

internal/services/dataevent/dataevent.go

@@ -18,7 +18,9 @@ import "github.com/wailsapp/wails/v3/pkg/application"
 
 // Changed is the live-sync event payload: which kind of entity changed
 // (e.g. "workflow", "request", "list", "mcpserver", "decision",
-// "execenv", "guardrail-rule", "run") and its ID.
+// "execenv", "guardrail-rule", "run", "hotkey", "keybinding") and its
+// ID -- "hotkey" carries the workflow ID its combo binds to,
+// "keybinding" carries the command ID its combo overrides.
 type Changed struct {
 	Entity string `json:"entity"`
 	ID     string `json:"id"`

internal/services/executionsvc/executionservice.go

@@ -441,6 +441,12 @@ func (e *ExecutionService) RedriveRun(runID, fromNodeID string) (RunSummary, err
 	if err != nil {
 		return RunSummary{}, fmt.Errorf("redrive: %w", err)
 	}
+	// The fork enters DBOS via ForkWorkflow, not runWorkflowStart, so the
+	// latter's own start emit never fires for forkedID -- announce it
+	// here so an open Runs panel shows the redriven run immediately
+	// rather than only once it completes (runWorkflow's own completion
+	// emit still covers that half).
+	dataevent.Emit("run", forkedID)
 	if _, err := handle.GetResult(); err != nil {
 		_ = err // see RunWorkflowDurable's identical comment
 	}

internal/services/executionsvc/executionservice_cancel.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/alicoding/mill/internal/adapters/execution"
 	"github.com/alicoding/mill/internal/adapters/procexec"
+	"github.com/alicoding/mill/internal/services/dataevent"
 )
 
 // Cancellation (docs/adr/0026's Amendment, goal 0004b): DBOS cannot
@@ -101,6 +102,14 @@ func (e *ExecutionService) CancelRun(runID string) error {
 		// skips run-cancelled itself (see its own comment) so this run
 		// isn't reported twice.
 		e.emitSystemEvent(SystemEventRunCancelled, runID, "")
+		// A run cancelled while still ENQUEUED never reaches runWorkflow
+		// at all (DBOS never dequeues it), so that function's own
+		// completion emit never fires -- this is the only live-sync
+		// signal such a run gets. A run cancelled while already RUNNING
+		// also gets runWorkflow's unconditional completion emit once its
+		// step unwinds; a second mill-data-changed for the same run is
+		// harmless (a refetch, not a state mutation).
+		dataevent.Emit("run", runID)
 	}
 	return err
 }