Add an in-app Recent activity feed for hotkey-triggered actions

A fired hotkey runs headlessly (writes straight to the clipboard, per
§2.2) with zero UI feedback either way -- a correctly-firing hotkey and
a silently swallowed one looked identical from the app itself. Emits a
HotkeyActivity event (Wails typed event, same pattern as the existing
footer clock) at each fire-path outcome; RunbookView subscribes and
renders the last 5 as a capped, in-memory feed. Complements the
terminal-only slog lines from the previous commit rather than
replacing them -- this is the in-app view of the same information.

Also parks a note in SPEC.md: RunbookView is up to 8 useState hooks and
showing real scaling pressure, but a state-management library isn't
warranted yet with only one stateful view -- revisit once a second view
needs to share state with it.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01C7zUjYuMtgetjNaxMQPg2h

Author: alicoding

docs/SPEC.md

@@ -186,6 +186,14 @@ and [`docs/adr/0002-cicd-pipeline-phased-rollout.md`](adr/0002-cicd-pipeline-pha
 - npm workspaces (`frontend/` + a future `browser-extension/`, §5) — not
   adopted yet, revisit when a real second JS package is scaffolded. `go.work`
   not applicable — single Go module is permanent per §1.1. `PARKED`
+- Frontend state management (Zustand or similar) — noted, not adopted.
+  `RunbookView.tsx` is up to 8 `useState` hooks (actions, hotkey bindings,
+  run results/errors, recording state, activity feed) and prop-drilling/
+  scaling pressure is visible, but it's still one view with genuinely
+  local state — reaching for a state library now would be the same
+  premature-architecture mistake CLAUDE.md already warns against for the
+  backend. Revisit once a second stateful view needs to share state with
+  Runbook, not before. `PARKED`
 - CI: GitHub Actions, all four ADR-0002 phases shipped in
   `.github/workflows/ci.yml` + `.github/workflows/release.yml`.
   `golangci-lint` v2, ESLint flat config, Vitest, `go test -race -cover`,

frontend/bindings/github.com/alicoding/mill/hotkeyservice.ts

@@ -6,6 +6,13 @@
  * Runbook action. Assignments are in-memory only for now — they don't
  * survive an app restart. Persistence is a deliberate follow-up, not
  * built into this first pass.
+ * 
+ * The fire path (OS delivers a keypress -> action runs -> clipboard is
+ * written) has no UI surface at all, unlike the Run button's inline
+ * success/error rendering — a hotkey that's registered but never fires
+ * (e.g. the combo is already claimed by another app, or macOS just never
+ * delivers it) is otherwise silent and undebuggable. logger makes every
+ * stage of that path visible instead of guessing.
  * @module
  */
 

frontend/bindings/github.com/alicoding/mill/index.ts

@@ -9,3 +9,7 @@ export {
     RunbookService,
     SpecService
 };
+
+export type {
+    HotkeyActivity
+} from "./models.js";

frontend/bindings/github.com/alicoding/mill/models.ts

@@ -0,0 +1,18 @@
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+/**
+ * HotkeyActivity is emitted once a fired hotkey resolves (success or
+ * failure). The Go-side slog lines (hotkeyservice.go) log the same
+ * information for terminal/`task dev` visibility; this event is the
+ * in-app equivalent, so a hotkey's outcome is visible without a
+ * terminal — added after a real hotkey worked correctly (fired, ran,
+ * wrote to the clipboard) but looked from the UI like nothing happened,
+ * because nothing in the UI ever said otherwise.
+ */
+export interface HotkeyActivity {
+    "actionID": string;
+    "binding": string;
+    "success": boolean;
+    "detail": string;
+}

frontend/bindings/github.com/wailsapp/wails/v3/internal/eventdata.d.ts

@@ -5,9 +5,14 @@
 // @ts-ignore: Unused imports
 import type { Events } from "@wailsio/runtime";
 
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: Unused imports
+import type * as main$0 from "../../../../alicoding/mill/models.js";
+
 declare module "@wailsio/runtime" {
     namespace Events {
         interface CustomEvents {
+            "hotkey-activity": main$0.HotkeyActivity;
             "time": string;
         }
     }

frontend/public/style.css

@@ -197,3 +197,8 @@ nav[aria-label="Mill"] {
     max-height: 240px;
     overflow-y: auto;
 }
+.runbook-activity-heading { margin-top: var(--s-4); }
+.runbook-activity-row {
+    padding: var(--base-size-4) 0;
+    border-bottom: 1px solid var(--borderColor-muted);
+}

frontend/src/RunbookView.tsx

@@ -1,10 +1,20 @@
 import { useEffect, useState } from 'react'
+import { Events } from '@wailsio/runtime'
 import { Button, Heading, Label, type LabelProps, SkeletonBox, Stack, Text } from '@primer/react'
-import { BeakerIcon, KeyIcon, MarkdownIcon } from '@primer/octicons-react'
+import { BeakerIcon, CheckCircleIcon, KeyIcon, MarkdownIcon, XCircleIcon } from '@primer/octicons-react'
 import { RunbookService, HotkeyService } from '../bindings/github.com/alicoding/mill'
+import type { HotkeyActivity } from '../bindings/github.com/alicoding/mill/models'
 import type { Action } from '../bindings/github.com/alicoding/mill/internal/domain/runbook/models'
 import { keyFromEventCode, modsFromEvent } from './keybinding'
 
+// A fired hotkey has no other UI surface — it runs headlessly and writes
+// straight to the clipboard (§2.2). Without this feed, a correctly firing
+// hotkey and a silently swallowed one look identical from the UI: nothing
+// visibly happens either way. Capped and in-memory only, same as the
+// bindings themselves — see SPEC.md §2.2's "Hotkey fire path is logged
+// end-to-end" entry.
+const MAX_ACTIVITY_ENTRIES = 5
+
 // Per-action leading icon. Falls back to KeyIcon for any future action not
 // listed here rather than rendering nothing.
 const ACTION_ICONS: Record<string, typeof BeakerIcon> = {
@@ -35,12 +45,20 @@ function RunbookView() {
   const [bindings, setBindings] = useState<Record<string, string>>({})
   const [bindingErrors, setBindingErrors] = useState<Record<string, string>>({})
   const [recordingId, setRecordingId] = useState<string | null>(null)
+  const [activity, setActivity] = useState<(HotkeyActivity & { id: string; time: string })[]>([])
 
   useEffect(() => {
     RunbookService.List().then((list) => setActions(list ?? [])).catch(console.error)
     HotkeyService.List().then((list) => setBindings((list ?? {}) as Record<string, string>)).catch(console.error)
   }, [])
 
+  useEffect(() => {
+    return Events.On('hotkey-activity', (evt) => {
+      const entry = { ...evt.data, id: crypto.randomUUID(), time: new Date().toLocaleTimeString() }
+      setActivity((prev) => [entry, ...prev].slice(0, MAX_ACTIVITY_ENTRIES))
+    })
+  }, [])
+
   useEffect(() => {
     if (!recordingId) return
 
@@ -165,8 +183,36 @@ function RunbookView() {
           })}
         </Stack>
       )}
+
+      {activity.length > 0 && (
+        <>
+          <Heading as="h2" variant="small" className="runbook-activity-heading">Recent activity</Heading>
+          <Text as="p" size="small" className="runbook-muted runbook-subtitle">
+            What fired hotkeys actually did — hotkey triggers run headlessly with no other feedback.
+          </Text>
+          <Stack direction="vertical" gap="condensed">
+            {activity.map((entry) => (
+              <Stack key={entry.id} direction="horizontal" align="center" gap="condensed" className="runbook-activity-row">
+                {entry.success ? (
+                  <CheckCircleIcon size={16} fill="var(--fgColor-success)" />
+                ) : (
+                  <XCircleIcon size={16} fill="var(--fgColor-danger)" />
+                )}
+                <Text size="small" className="runbook-muted">{entry.time}</Text>
+                <Label variant="secondary" size="small">{entry.binding}</Label>
+                <Text size="small">{actionName(actions, entry.actionID)}</Text>
+                <Text size="small" className="runbook-muted">— {entry.detail}</Text>
+              </Stack>
+            ))}
+          </Stack>
+        </>
+      )}
     </div>
   )
 }
 
+function actionName(actions: Action[] | null, actionID: string): string {
+  return actions?.find((a) => a.ID === actionID)?.Name ?? actionID
+}
+
 export default RunbookView

hotkeyservice.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/alicoding/mill/internal/adapters/clipboard"
 	"github.com/alicoding/mill/internal/adapters/hotkey"
+	"github.com/wailsapp/wails/v3/pkg/application"
 )
 
 var modSymbol = map[string]string{
@@ -83,13 +84,16 @@ func (h *HotkeyService) Assign(actionID string, mods []string, key string) (stri
 			result, err := h.runbook.Run(actionID)
 			if err != nil {
 				h.logger.Error("hotkey action failed", "action", actionID, "binding", label, "error", err)
+				emitHotkeyActivity(actionID, label, false, err.Error())
 				continue
 			}
 			if err := clipboard.WriteText(result); err != nil {
 				h.logger.Error("hotkey result clipboard write failed", "action", actionID, "binding", label, "error", err)
+				emitHotkeyActivity(actionID, label, false, "clipboard write failed: "+err.Error())
 				continue
 			}
 			h.logger.Info("hotkey action completed", "action", actionID, "binding", label, "output_bytes", len(result))
+			emitHotkeyActivity(actionID, label, true, fmt.Sprintf("copied to clipboard (%d bytes)", len(result)))
 		}
 	}()
 
@@ -125,3 +129,18 @@ func formatBinding(mods []string, key string) string {
 	b.WriteString(strings.ToUpper(key))
 	return b.String()
 }
+
+// emitHotkeyActivity pushes a HotkeyActivity event to the frontend so a
+// fired hotkey's outcome is visible in the app itself, not just in the
+// slog lines above (terminal-only, and only during `task dev`).
+// application.Get() is safe to call here: this only ever runs from the
+// Keydown() goroutine, which can't fire before application.New has run
+// and registered the global app instance.
+func emitHotkeyActivity(actionID, binding string, success bool, detail string) {
+	application.Get().Event.Emit("hotkey-activity", HotkeyActivity{
+		ActionID: actionID,
+		Binding:  binding,
+		Success:  success,
+		Detail:   detail,
+	})
+}

main.go

@@ -18,11 +18,26 @@ import (
 //go:embed all:frontend/dist
 var assets embed.FS
 
+// HotkeyActivity is emitted once a fired hotkey resolves (success or
+// failure). The Go-side slog lines (hotkeyservice.go) log the same
+// information for terminal/`task dev` visibility; this event is the
+// in-app equivalent, so a hotkey's outcome is visible without a
+// terminal — added after a real hotkey worked correctly (fired, ran,
+// wrote to the clipboard) but looked from the UI like nothing happened,
+// because nothing in the UI ever said otherwise.
+type HotkeyActivity struct {
+	ActionID string `json:"actionID"`
+	Binding  string `json:"binding"`
+	Success  bool   `json:"success"`
+	Detail   string `json:"detail"`
+}
+
 func init() {
 	// Register a custom event whose associated data type is string.
 	// This is not required, but the binding generator will pick up registered events
 	// and provide a strongly typed JS/TS API for them.
 	application.RegisterEvent[string]("time")
+	application.RegisterEvent[HotkeyActivity]("hotkey-activity")
 }
 
 // main function serves as the application's entry point. It initializes the application, creates a window,