diff --git a/Makefile b/Makefile
index fdd6e12..67b10eb 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 .PHONY: build run test fmt vet package package-host clean
 
 BIN := bin/kandev-plugin-notes
-VERSION := 0.1.0
+VERSION := 0.2.0
 STAGE := .build/stage
 PKG_OUT := kandev-plugin-notes-$(VERSION).tar.gz
 
diff --git a/README.md b/README.md
index 4b7e1b7..5d5036d 100644
--- a/README.md
+++ b/README.md
@@ -1,28 +1,49 @@
 # kandev-plugin-notes
 
 A [Kandev](https://github.com/kdlbs/kandev) plugin that gives every task a
-private, rich-text notes scratchpad.
+private markdown notes scratchpad, with a formatting toolbar and optional
+AI-assisted proofreading.
 
 ## What it does
 
 - **Notes task panel** — a dockview panel in the task workspace (`+` → Notes),
   also available on a phone under the grouped **Panels** bottom-nav action.
-  Rich-text editing (headings, lists, code blocks) via the host's own tiptap
-  editor, with debounced autosave.
+- **Markdown editing with a formatting toolbar** — a scrollable markdown
+  `<textarea>` (bold, italic, headings, bullet/numbered lists, links, inline
+  code, and code blocks), shared byte-for-byte by the task panel and the
+  kanban modal, with debounced autosave. The toolbar's actions insert or wrap
+  the right markdown around your current selection (or at the caret) so you
+  never have to remember the syntax.
+- **Enhance with AI** — a button next to the toolbar sends the note's current
+  markdown to your configured utility agent to proofread grammar, spelling,
+  and clarity. The result is shown as a preview with **Accept**/**Discard**
+  before it ever replaces your note — nothing is overwritten automatically.
+  See "Notes are private to you" below for the privacy trade-off this makes.
 - **Kanban shortcut** — `Edit > Edit notes` on a kanban card opens the same
-  editor in a modal, so you can jot something down without opening the task.
+  editor (toolbar, AI button included) in a fixed-size modal — the modal
+  itself never grows as you type; the editor scrolls internally instead.
 - **Card indicator** — a small glyph on cards that have a note.
 - **Cross-tab sync** — an edit in one tab shows up in another without a reload.
 
-## Notes are private to you
+## Notes are private to you — except when you ask AI to enhance one
 
 Each note is stored per **user**, per **task**, under the plugin's own key
 (`("task", <taskId>, "note")`) via Kandev's per-user plugin storage
 (`capabilities.user_state`). Two people looking at the same task each see their
-own note; nobody else can read yours, and the agent cannot read or write it.
+own note; nobody else can read yours, and the agent working the task cannot
+read or write it.
 
-If you want the agent to see something, put it in the task description or say it
-in chat. This is a scratchpad, not a shared field.
+**The one exception is the "Enhance with AI" button.** Clicking it sends the
+note's current markdown to the utility agent configured for this plugin
+(**Settings > Plugins > Notes**) via a one-shot completion
+(`capabilities.agent_invoke` / `Host.InvokeUtilityAgent`) — that content
+leaves the "nobody else can read it" boundary for that one request. If no
+utility agent is configured, the button shows a clear, non-fatal message
+instead of failing silently. Skip the button entirely to keep a note fully
+private.
+
+If you want the task's own agent to see something, put it in the task
+description or say it in chat. This is a scratchpad, not a shared field.
 
 ## Install
 
@@ -37,7 +58,10 @@ curl -F "package=@kandev-plugin-notes-<version>.tar.gz" \
 
 Sideloaded plugins register disabled/unverified; enable it in
 **Settings > Plugins**. Reinstalling the same version returns 409 — bump the
-version in `manifest.yaml` (and `Makefile`) first.
+version in `manifest.yaml` (and `Makefile`) first. To use "Enhance with AI",
+also pick a utility agent for this plugin under **Settings > Plugins > Notes**
+(`config_schema.utility_agent`) — without one, the button surfaces a
+not-configured message rather than failing.
 
 ## Development
 
@@ -65,3 +89,29 @@ and the [manifest reference](https://github.com/kdlbs/kandev/blob/main/docs/publ
 ## License
 
 MIT — see [LICENSE](LICENSE).
+
+
+The Kandev plugin SDK (`pkg/pluginsdk`) is not yet published as a standalone Go
+module, so `go.mod` uses a local `replace` that expects the Kandev monorepo as a
+**sibling checkout**:
+
+```text
+some-dir/
+├── kandev/                 # https://github.com/kdlbs/kandev — Go module at apps/backend/
+└── kandev-plugin-notes/    # this repo
+```
+
+```sh
+make build   # host binary
+make test    # Go + JS unit tests
+make vet
+make package-host   # host-platform package — fastest local loop
+make package        # all five platforms
+```
+
+Start with the [plugin authoring guide](https://github.com/kdlbs/kandev/blob/main/docs/public/plugins-authoring.md)
+and the [manifest reference](https://github.com/kdlbs/kandev/blob/main/docs/public/plugins-manifest.md).
+
+## License
+
+MIT — see [LICENSE](LICENSE).
diff --git a/go.mod b/go.mod
index 2f57db0..90bc0f0 100644
--- a/go.mod
+++ b/go.mod
@@ -5,6 +5,7 @@ go 1.26.0
 require (
 	github.com/kandev/kandev v0.0.0-00010101000000-000000000000
 	github.com/stretchr/testify v1.11.1
+	google.golang.org/grpc v1.82.1
 	gopkg.in/yaml.v3 v3.0.1
 )
 
@@ -23,7 +24,6 @@ require (
 	golang.org/x/sys v0.46.0 // indirect
 	golang.org/x/text v0.39.0 // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20260414002931-afd174a4e478 // indirect
-	google.golang.org/grpc v1.82.1 // indirect
 	google.golang.org/protobuf v1.36.11 // indirect
 )
 
diff --git a/manifest.yaml b/manifest.yaml
index 507a3e7..1095d9b 100644
--- a/manifest.yaml
+++ b/manifest.yaml
@@ -5,9 +5,9 @@
 # (/api/plugins/<id>/...). Keep the three in sync when bumping version.
 id: "kandev-plugin-notes"
 api_version: 1
-version: "0.1.0"
+version: "0.2.0"
 display_name: "Notes"
-description: "A private, per-user scratchpad note on any task: a dockview/mobile panel, rich-text editing, and a kanban card shortcut."
+description: "A private, per-user scratchpad note on any task: a dockview/mobile panel, markdown editing with a formatting toolbar, AI-assisted proofreading, and a kanban card shortcut."
 author: "yattdev"
 categories: ["tools"]
 repo_url: "https://github.com/yattdev/kandev-plugin-notes"
@@ -26,10 +26,32 @@ runtime:
     windows-amd64: "server/plugin-windows-amd64.exe"
 
 # capabilities gate what the host will do for this plugin. This plugin needs
-# only per-user browser-reachable storage (host.storage) for the note itself
-# — no events, no Host state, no webhooks, no API read/write.
+# per-user browser-reachable storage (host.storage) for the note itself, plus
+# agent_invoke so the "Enhance with AI" button can run a one-shot proofreading
+# completion via Host.InvokeUtilityAgent (see server/plugin.go and the
+# `utility_agent` config property below).
 capabilities:
   user_state: true
+  agent_invoke: true
+
+# webhooks: the "Enhance with AI" button POSTs the note's current markdown to
+# this webhook (relayed at POST /api/plugins/kandev-plugin-notes/webhooks/enhance);
+# server/plugin.go's HandleWebhook proofreads it via Host.InvokeUtilityAgent
+# and returns the improved markdown for the UI's preview/Accept/Discard flow.
+webhooks:
+  - key: "enhance"
+    description: "Proofread and improve the current note's markdown via the configured utility agent"
+    method: "POST"
+
+# config_schema: agent_invoke requires a utility_agent picker (rendered at
+# Settings > Plugins > Notes) so the operator selects which agent runs the
+# enhance completion. Calling Host.InvokeUtilityAgent without a valid
+# selection here returns a distinguishable FailedPrecondition (see
+# server/plugin.go), surfaced by the UI as a non-fatal message.
+config_schema:
+  type: object
+  properties:
+    utility_agent: { type: string, format: utility-agent, title: "Utility Agent", description: "Agent used to proofread notes for the Enhance with AI button" }
 
 # ui.bundle points at the hand-written, no-build ES module frontend half.
 ui:
diff --git a/server/manifest_test.go b/server/manifest_test.go
index 08623b1..778fd9d 100644
--- a/server/manifest_test.go
+++ b/server/manifest_test.go
@@ -113,15 +113,26 @@ func TestManifestVersion_MatchesMakefileVersion(t *testing.T) {
 	require.Equal(t, m.Version, makefileVersion(t))
 }
 
-func TestManifestCapabilities_OnlyUserState(t *testing.T) {
+func TestManifestCapabilities_UserStateAndAgentInvoke(t *testing.T) {
 	m := loadManifest(t)
-	require.Equal(t, map[string]any{"user_state": true}, m.Capabilities)
+	require.Equal(t, map[string]any{"user_state": true, "agent_invoke": true}, m.Capabilities)
 }
 
-func TestManifest_NoWebhooksOrConfigSchema(t *testing.T) {
+func TestManifest_DeclaresEnhanceWebhookAndUtilityAgentConfig(t *testing.T) {
 	m := loadManifest(t)
-	require.Empty(t, m.Webhooks)
-	require.Empty(t, m.ConfigSchema)
+	require.Len(t, m.Webhooks, 1)
+	webhook, ok := m.Webhooks[0].(map[string]any)
+	require.True(t, ok, "webhooks[0] should decode as a map")
+	require.Equal(t, "enhance", webhook["key"])
+	require.Equal(t, "POST", webhook["method"])
+
+	require.NotEmpty(t, m.ConfigSchema)
+	properties, ok := m.ConfigSchema["properties"].(map[string]any)
+	require.True(t, ok, "config_schema.properties should decode as a map")
+	utilityAgent, ok := properties["utility_agent"].(map[string]any)
+	require.True(t, ok, "config_schema.properties.utility_agent should decode as a map")
+	require.Equal(t, "string", utilityAgent["type"])
+	require.Equal(t, "utility-agent", utilityAgent["format"])
 }
 
 func TestManifestUI_BundlePathHasLeadingSlash(t *testing.T) {
diff --git a/server/plugin.go b/server/plugin.go
index 4742504..d7a1ea1 100644
--- a/server/plugin.go
+++ b/server/plugin.go
@@ -1,19 +1,125 @@
 // Package main implements the backend half of kandev-plugin-notes.
 //
-// This plugin has no backend behavior: the note itself lives in per-user
-// host.storage, a browser-reachable capability with no Go-side counterpart
-// (see manifest.yaml's capabilities.user_state and ui/bundle.js). notesPlugin
-// exists only because kandev's installer requires runtime.type: binary — it
-// declares no events, no webhooks, and no config, and never overrides
-// UnimplementedPlugin's no-op RPCs.
+// The note itself still lives entirely in per-user host.storage, a
+// browser-reachable capability with no Go-side counterpart (see
+// manifest.yaml's capabilities.user_state and ui/bundle.js) — this backend
+// never reads or writes note content directly. Its one job is the
+// "Enhance with AI" feature: relay the note's current markdown to the
+// operator-configured utility agent (capabilities.agent_invoke,
+// Host.InvokeUtilityAgent) via a single webhook and return the proofread
+// markdown, so the frontend never needs its own LLM credentials. OnEvent
+// stays the UnimplementedPlugin no-op — this plugin subscribes to no events.
 package main
 
-import "github.com/kandev/kandev/pkg/pluginsdk"
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/kandev/kandev/pkg/pluginsdk"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+// enhanceWebhookKey is this plugin's single webhook key (manifest.yaml
+// webhooks[].key: "enhance"), reachable at
+// POST /api/plugins/kandev-plugin-notes/webhooks/enhance.
+const enhanceWebhookKey = "enhance"
+
+// enhancePromptTemplate wraps the note's markdown in a proofreading
+// instruction for the one-shot utility-agent completion. The agent is asked
+// to return markdown only, matching this plugin's storage format, so the
+// response can replace the note verbatim (after the UI's preview/accept
+// step) with no reformatting.
+const enhancePromptTemplate = `You are a proofreading assistant for a short personal note written in Markdown. Improve grammar, spelling, clarity, and formatting while preserving the author's meaning, tone, and structure. Keep the same Markdown syntax (headings, lists, links, code blocks, emphasis) and do not add commentary, explanations, or a preamble — respond with only the improved Markdown note.
+
+Note:
+%s`
+
+// enhanceRequestBody is the JSON body accepted by the enhance webhook.
+type enhanceRequestBody struct {
+	Content string `json:"content"`
+}
+
+// enhanceResponseBody is the JSON body returned by the enhance webhook on
+// success: the proofread markdown, under the same field name the UI sent so
+// the client can reuse one shape for the request and response.
+type enhanceResponseBody struct {
+	Content string `json:"content"`
+}
+
+// enhanceErrorBody is the JSON body returned on a handled failure (missing
+// utility agent, bad input) — a stable {error} shape the UI can surface
+// without parsing prose out of a plain-text body.
+type enhanceErrorBody struct {
+	Error string `json:"error"`
+}
 
 // notesPlugin implements pluginsdk.Plugin via UnimplementedPlugin's no-op
-// defaults. It intentionally overrides nothing.
+// defaults for everything except HandleWebhook, which it overrides to
+// service the "enhance" key below.
 type notesPlugin struct {
 	pluginsdk.UnimplementedPlugin
 }
 
 var _ pluginsdk.Plugin = (*notesPlugin)(nil)
+
+// HandleWebhook services the "enhance" webhook key: POST {content} ->
+// {content: <proofread markdown>}. Any other key returns 404, matching
+// UnimplementedPlugin's default for undeclared routes. A missing Host,
+// wrong method, or empty content are all guarded before ever calling
+// Host.InvokeUtilityAgent.
+func (p *notesPlugin) HandleWebhook(ctx context.Context, req *pluginsdk.WebhookRequest) (*pluginsdk.WebhookResponse, error) {
+	if req == nil || req.WebhookKey != enhanceWebhookKey {
+		return &pluginsdk.WebhookResponse{Status: http.StatusNotFound}, nil
+	}
+	if req.Method != http.MethodPost {
+		return jsonErrorResponse(http.StatusMethodNotAllowed, "enhance requires POST")
+	}
+
+	var body enhanceRequestBody
+	if err := json.Unmarshal(req.Body, &body); err != nil {
+		return jsonErrorResponse(http.StatusBadRequest, "invalid request body")
+	}
+	if body.Content == "" {
+		return jsonErrorResponse(http.StatusBadRequest, "content must not be empty")
+	}
+
+	host := p.Host()
+	if host == nil {
+		return jsonErrorResponse(http.StatusServiceUnavailable, "plugin host unavailable")
+	}
+
+	improved, err := host.InvokeUtilityAgent(ctx, fmt.Sprintf(enhancePromptTemplate, body.Content))
+	if err != nil {
+		if status.Code(err) == codes.FailedPrecondition {
+			// No utility agent configured (or the configured one was
+			// deleted/disabled) — a distinguishable, non-fatal condition
+			// per ADR 0048, not an internal error.
+			return jsonErrorResponse(http.StatusPreconditionFailed, "no utility agent is configured for this plugin — configure one in Settings > Plugins > Notes")
+		}
+		return jsonErrorResponse(http.StatusBadGateway, "AI enhancement failed")
+	}
+
+	return jsonResponse(http.StatusOK, enhanceResponseBody{Content: improved})
+}
+
+// jsonResponse marshals body as the JSON WebhookResponse payload for status.
+func jsonResponse(status int32, body any) (*pluginsdk.WebhookResponse, error) {
+	payload, err := json.Marshal(body)
+	if err != nil {
+		return jsonErrorResponse(http.StatusInternalServerError, "internal error")
+	}
+	return &pluginsdk.WebhookResponse{
+		Status:  status,
+		Headers: map[string]string{"Content-Type": "application/json"},
+		Body:    payload,
+	}, nil
+}
+
+// jsonErrorResponse is jsonResponse for the {error} shape, used on every
+// handled failure path above.
+func jsonErrorResponse(status int32, message string) (*pluginsdk.WebhookResponse, error) {
+	return jsonResponse(status, enhanceErrorBody{Error: message})
+}
diff --git a/server/plugin_test.go b/server/plugin_test.go
index 7f501cc..a87876b 100644
--- a/server/plugin_test.go
+++ b/server/plugin_test.go
@@ -1,23 +1,28 @@
-// Package main tests. notesPlugin has no overridden RPCs, so these tests
-// pin the no-op defaults it inherits from UnimplementedPlugin: OnEvent
-// acknowledges without side effects and HandleWebhook answers 404 for any
-// key, with or without a Host injected.
+// Package main tests. notesPlugin overrides only HandleWebhook (for the
+// "enhance" webhook key); OnEvent still pins the no-op default it inherits
+// from UnimplementedPlugin, and HandleWebhook still answers 404 for any
+// other key, with or without a Host injected.
 package main
 
 import (
 	"context"
+	"encoding/json"
 	"testing"
 
 	"github.com/kandev/kandev/pkg/pluginsdk"
 	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
 )
 
-// fakeHost is a minimal pluginsdk.Host test double. notesPlugin never calls
-// any Host method, so every accessor is a bare stub; UnimplementedHostData
-// covers the data-API sub-accessors (Tasks/Sessions/...), and the state/
-// secret/event methods below cover the rest of the interface.
+// fakeHost is a minimal pluginsdk.Host test double. notesPlugin only calls
+// InvokeUtilityAgent, so that is the one overridable stub; every other
+// accessor is a bare no-op. UnimplementedHostData covers the data-API
+// sub-accessors (Tasks/Sessions/...), and the state/secret/event methods
+// below cover the rest of the interface.
 type fakeHost struct {
 	pluginsdk.UnimplementedHostData
+	invokeUtilityAgent func(ctx context.Context, prompt string) (string, error)
 }
 
 func (fakeHost) GetState(context.Context, string, string, string) (map[string]any, bool, error) {
@@ -37,6 +42,13 @@ func (fakeHost) SetSecret(context.Context, string, string) error         { retur
 func (fakeHost) DeleteSecret(context.Context, string) error              { return nil }
 func (fakeHost) EmitEvent(context.Context, string, map[string]any) error { return nil }
 
+func (h fakeHost) InvokeUtilityAgent(ctx context.Context, prompt string) (string, error) {
+	if h.invokeUtilityAgent != nil {
+		return h.invokeUtilityAgent(ctx, prompt)
+	}
+	return "", nil
+}
+
 var _ pluginsdk.Host = (*fakeHost)(nil)
 
 func TestPlugin_ImplementsPluginInterface(t *testing.T) {
@@ -66,7 +78,7 @@ func TestHandleWebhook_NoHost_Returns404(t *testing.T) {
 	require.Equal(t, int32(404), resp.Status)
 }
 
-func TestHandleWebhook_WithHost_Returns404(t *testing.T) {
+func TestHandleWebhook_WithHost_UnknownKey_Returns404(t *testing.T) {
 	p := &notesPlugin{}
 	p.SetHost(&fakeHost{})
 	resp, err := p.HandleWebhook(context.Background(), &pluginsdk.WebhookRequest{
@@ -76,3 +88,124 @@ func TestHandleWebhook_WithHost_Returns404(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, int32(404), resp.Status)
 }
+
+func TestHandleWebhook_Enhance_HappyPath_ReturnsImprovedContent(t *testing.T) {
+	p := &notesPlugin{}
+	var capturedPrompt string
+	p.SetHost(&fakeHost{invokeUtilityAgent: func(_ context.Context, prompt string) (string, error) {
+		capturedPrompt = prompt
+		return "# Improved\n\nBetter note.", nil
+	}})
+
+	body, err := json.Marshal(map[string]string{"content": "# heading\n\nsome typo'd note"})
+	require.NoError(t, err)
+
+	resp, err := p.HandleWebhook(context.Background(), &pluginsdk.WebhookRequest{
+		WebhookKey: "enhance",
+		Method:     "POST",
+		Body:       body,
+	})
+	require.NoError(t, err)
+	require.Equal(t, int32(200), resp.Status)
+	require.Contains(t, capturedPrompt, "some typo'd note")
+
+	var out enhanceResponseBody
+	require.NoError(t, json.Unmarshal(resp.Body, &out))
+	require.Equal(t, "# Improved\n\nBetter note.", out.Content)
+}
+
+func TestHandleWebhook_Enhance_NonPost_ReturnsMethodNotAllowed(t *testing.T) {
+	p := &notesPlugin{}
+	p.SetHost(&fakeHost{})
+
+	resp, err := p.HandleWebhook(context.Background(), &pluginsdk.WebhookRequest{
+		WebhookKey: "enhance",
+		Method:     "GET",
+	})
+	require.NoError(t, err)
+	require.Equal(t, int32(405), resp.Status)
+}
+
+func TestHandleWebhook_Enhance_EmptyContent_ReturnsBadRequest(t *testing.T) {
+	p := &notesPlugin{}
+	p.SetHost(&fakeHost{})
+
+	body, err := json.Marshal(map[string]string{"content": ""})
+	require.NoError(t, err)
+
+	resp, err := p.HandleWebhook(context.Background(), &pluginsdk.WebhookRequest{
+		WebhookKey: "enhance",
+		Method:     "POST",
+		Body:       body,
+	})
+	require.NoError(t, err)
+	require.Equal(t, int32(400), resp.Status)
+}
+
+func TestHandleWebhook_Enhance_InvalidJSON_ReturnsBadRequest(t *testing.T) {
+	p := &notesPlugin{}
+	p.SetHost(&fakeHost{})
+
+	resp, err := p.HandleWebhook(context.Background(), &pluginsdk.WebhookRequest{
+		WebhookKey: "enhance",
+		Method:     "POST",
+		Body:       []byte("not json"),
+	})
+	require.NoError(t, err)
+	require.Equal(t, int32(400), resp.Status)
+}
+
+func TestHandleWebhook_Enhance_NoHost_ReturnsServiceUnavailable(t *testing.T) {
+	p := &notesPlugin{}
+
+	body, err := json.Marshal(map[string]string{"content": "hello"})
+	require.NoError(t, err)
+
+	resp, err := p.HandleWebhook(context.Background(), &pluginsdk.WebhookRequest{
+		WebhookKey: "enhance",
+		Method:     "POST",
+		Body:       body,
+	})
+	require.NoError(t, err)
+	require.Equal(t, int32(503), resp.Status)
+}
+
+func TestHandleWebhook_Enhance_NoUtilityAgentConfigured_ReturnsPreconditionFailed(t *testing.T) {
+	p := &notesPlugin{}
+	p.SetHost(&fakeHost{invokeUtilityAgent: func(context.Context, string) (string, error) {
+		return "", status.Error(codes.FailedPrecondition, "no utility agent configured for this plugin")
+	}})
+
+	body, err := json.Marshal(map[string]string{"content": "hello"})
+	require.NoError(t, err)
+
+	resp, err := p.HandleWebhook(context.Background(), &pluginsdk.WebhookRequest{
+		WebhookKey: "enhance",
+		Method:     "POST",
+		Body:       body,
+	})
+	require.NoError(t, err)
+	require.Equal(t, int32(412), resp.Status)
+
+	var out enhanceErrorBody
+	require.NoError(t, json.Unmarshal(resp.Body, &out))
+	require.NotEmpty(t, out.Error)
+}
+
+func TestHandleWebhook_Enhance_OtherAgentError_ReturnsBadGateway(t *testing.T) {
+	p := &notesPlugin{}
+	p.SetHost(&fakeHost{invokeUtilityAgent: func(context.Context, string) (string, error) {
+		return "", status.Error(codes.Internal, "boom")
+	}})
+
+	body, err := json.Marshal(map[string]string{"content": "hello"})
+	require.NoError(t, err)
+
+	resp, err := p.HandleWebhook(context.Background(), &pluginsdk.WebhookRequest{
+		WebhookKey: "enhance",
+		Method:     "POST",
+		Body:       body,
+	})
+	require.NoError(t, err)
+	require.Equal(t, int32(502), resp.Status)
+}
diff --git a/ui/bundle.js b/ui/bundle.js
index 8f5c004..7c01d82 100644
--- a/ui/bundle.js
+++ b/ui/bundle.js
@@ -6,30 +6,294 @@
 // module. There is nothing to build: edit this file and repackage
 // (`make package` / `make package-host`).
 //
-// The plugin: a per-user, private scratchpad note on a task.
-//   - A task panel (registerTaskPanel, mobileEnabled) renders the note as
-//     rich text (host.ui.RichTextEditor) and autosaves through host.storage.
-//   - A kanban card menu action (registerTaskMenuAction, group "edit") opens
-//     the same editor in a modal, bound to that card's own taskId.
+// The plugin: a per-user, private scratchpad note on a task, edited as
+// markdown through one shared editor on both surfaces:
+//   - A task panel (registerTaskPanel, mobileEnabled) and
+//   - a kanban card menu action (registerTaskMenuAction, group "edit") that
+//     opens the same editor in a modal, bound to that card's own taskId.
+//   Both render a scrollable markdown `<textarea>` with a formatting
+//   toolbar (bold/italic/heading/lists/link/code) above it, and autosave
+//   through host.storage. This editor intentionally does not use
+//   host.ui.RichTextEditor (see makeNoteModalContent's history below for
+//   why the modal surface could never use it) — one markdown editor keeps
+//   both surfaces byte-identical and needs no host WYSIWYG dependency.
 //   - A task-card-indicators component shows a glyph when the task has a
 //     non-empty note.
+//   - An "Enhance with AI" button (both surfaces) sends the note's current
+//     markdown to this plugin's own `enhance` webhook
+//     (server/plugin.go -> Host.InvokeUtilityAgent) and previews the
+//     proofread result with Accept/Discard before it ever touches the
+//     stored note.
 //
 // The stateful logic (read guard, debounced write, conflict handling,
-// subscribe wiring, indicator cache) is factored into framework-free
-// functions below — no host.React, no DOM — so it is unit-testable with
-// `node --test` against a fake host (see ui/bundle.test.mjs). This file adds
-// `export` to those functions purely for that test import; the plugin still
-// registers itself the normal way, via window.registerKandevPlugin at
-// evaluation time. `id` below MUST match manifest.yaml's id.
+// subscribe wiring, indicator cache, markdown transforms, the enhance
+// preview state machine) is factored into framework-free functions below —
+// no host.React, no DOM — so it is unit-testable with `node --test` against
+// a fake host (see ui/bundle.test.mjs). This file adds `export` to those
+// functions purely for that test import; the plugin still registers itself
+// the normal way, via window.registerKandevPlugin at evaluation time. `id`
+// below MUST match manifest.yaml's id.
 //
 // host.storage is per-user (capabilities.user_state) — every read/write is
 // scoped to the calling user. This note is a private scratchpad, not a
 // document shared by everyone on the task; the empty-state copy below says
-// so explicitly.
+// so explicitly. AI enhance is the one documented exception to "the agent
+// cannot read your note": clicking it sends the note's current markdown to
+// the operator-configured utility agent (README's Privacy section explains
+// this trade-off).
 
 const NOTE_SCOPE = "task";
 const NOTE_KEY = "note";
 const WRITE_DEBOUNCE_MS = 150;
+const ENHANCE_WEBHOOK_PATH = "webhooks/enhance";
+
+// ---------------------------------------------------------------------------
+// Markdown transforms — pure functions, no DOM. Each takes the textarea's
+// full value and its current selection (selStart === selEnd when there is
+// no selection, i.e. just a caret) and returns { value, selStart, selEnd }:
+// the new textarea value plus the selection the toolbar action's caller
+// should apply afterwards (`textarea.setSelectionRange(selStart, selEnd)`),
+// so a formatting action either wraps the user's existing selection or
+// inserts a sensible placeholder that is itself selected for immediate
+// overtyping (e.g. bold/italic/link).
+// ---------------------------------------------------------------------------
+
+// wrapSelection is the shared "before + selection(or placeholder) + after"
+// transform behind bold/italic/inline-code: the wrapped text stays selected
+// afterwards so a second click toggles it back to plain text intuitively.
+function wrapSelection(text, selStart, selEnd, before, after, placeholder) {
+  const hasSelection = selEnd > selStart;
+  const inner = hasSelection ? text.slice(selStart, selEnd) : placeholder;
+  const value = text.slice(0, selStart) + before + inner + after + text.slice(selEnd);
+  const newSelStart = selStart + before.length;
+  return { value, selStart: newSelStart, selEnd: newSelStart + inner.length };
+}
+
+export function applyBold(text, selStart, selEnd) {
+  return wrapSelection(text, selStart, selEnd, "**", "**", "bold text");
+}
+
+export function applyItalic(text, selStart, selEnd) {
+  return wrapSelection(text, selStart, selEnd, "*", "*", "italic text");
+}
+
+export function applyInlineCode(text, selStart, selEnd) {
+  return wrapSelection(text, selStart, selEnd, "`", "`", "code");
+}
+
+export function applyCodeBlock(text, selStart, selEnd) {
+  const hasSelection = selEnd > selStart;
+  const inner = hasSelection ? text.slice(selStart, selEnd) : "code";
+  const before = "```\n";
+  const after = "\n```";
+  const value = text.slice(0, selStart) + before + inner + after + text.slice(selEnd);
+  const newSelStart = selStart + before.length;
+  return { value, selStart: newSelStart, selEnd: newSelStart + inner.length };
+}
+
+// applyLink wraps the selection (or a placeholder) as link text and appends
+// a `(url)` placeholder, then selects the url placeholder — so the very
+// next thing the user types replaces "https://" rather than the link text.
+export function applyLink(text, selStart, selEnd) {
+  const hasSelection = selEnd > selStart;
+  const linkText = hasSelection ? text.slice(selStart, selEnd) : "link text";
+  const urlPlaceholder = "https://";
+  const insertText = `[${linkText}](${urlPlaceholder})`;
+  const value = text.slice(0, selStart) + insertText + text.slice(selEnd);
+  const urlStart = selStart + `[${linkText}](`.length;
+  return { value, selStart: urlStart, selEnd: urlStart + urlPlaceholder.length };
+}
+
+// lineBounds returns the [start, end) character range of the line
+// containing `pos` (end excludes the trailing newline, matching how a
+// textarea reports lines).
+function lineBounds(text, pos) {
+  const start = text.lastIndexOf("\n", pos - 1) + 1;
+  const nextBreak = text.indexOf("\n", pos);
+  const end = nextBreak === -1 ? text.length : nextBreak;
+  return { start, end };
+}
+
+// lineRangeBounds extends lineBounds to cover every line touched by a
+// selection, so a multi-line selection toggles/prefixes every line, not
+// just the first.
+function lineRangeBounds(text, selStart, selEnd) {
+  const first = lineBounds(text, selStart);
+  const last = lineBounds(text, Math.max(selEnd - 1, selStart));
+  return { start: first.start, end: last.end };
+}
+
+// applyHeading toggles a Markdown ATX heading (default level 2) on the
+// line containing the caret/selection start: applying the same level again
+// removes it; applying while a different level is present replaces it.
+export function applyHeading(text, selStart, selEnd, level = 2) {
+  const { start, end } = lineBounds(text, selStart);
+  const line = text.slice(start, end);
+  const prefix = "#".repeat(level) + " ";
+  const existing = line.match(/^(#{1,6})\s+/);
+  let newLine;
+  let delta;
+  if (existing && existing[1].length === level) {
+    newLine = line.slice(existing[0].length);
+    delta = -existing[0].length;
+  } else if (existing) {
+    newLine = prefix + line.slice(existing[0].length);
+    delta = prefix.length - existing[0].length;
+  } else {
+    newLine = prefix + line;
+    delta = prefix.length;
+  }
+  const value = text.slice(0, start) + newLine + text.slice(end);
+  return {
+    value,
+    selStart: Math.max(start, selStart + delta),
+    selEnd: Math.max(start, selEnd + delta),
+  };
+}
+
+// applyBulletList / applyNumberedList toggle a list marker on every
+// non-blank line the selection touches. Toggling off requires every
+// non-blank line to already carry the marker; otherwise the action adds it
+// to whichever lines are missing it (so a partially-listified block
+// converges to "all listified" in one click, the common editor idiom).
+export function applyBulletList(text, selStart, selEnd) {
+  const { start, end } = lineRangeBounds(text, selStart, selEnd);
+  const block = text.slice(start, end);
+  if (selStart === selEnd && block.trim() === "") {
+    const marker = "- ";
+    const value = text.slice(0, start) + marker + block + text.slice(end);
+    return { value, selStart: selStart + marker.length, selEnd: selEnd + marker.length };
+  }
+  const lines = block.split("\n");
+  const bulletRe = /^-\s+/;
+  const allBulleted = lines.every((l) => bulletRe.test(l) || l.trim() === "");
+  const newLines = lines.map((l) => {
+    if (l.trim() === "") return l;
+    if (allBulleted) return l.replace(bulletRe, "");
+    return bulletRe.test(l) ? l : `- ${l}`;
+  });
+  const newBlock = newLines.join("\n");
+  const value = text.slice(0, start) + newBlock + text.slice(end);
+  const deltaFirstLine = newLines[0].length - lines[0].length;
+  const deltaTotal = newBlock.length - block.length;
+  return {
+    value,
+    selStart: Math.max(start, selStart + deltaFirstLine),
+    selEnd: Math.max(start, selEnd + deltaTotal),
+  };
+}
+
+export function applyNumberedList(text, selStart, selEnd) {
+  const { start, end } = lineRangeBounds(text, selStart, selEnd);
+  const block = text.slice(start, end);
+  if (selStart === selEnd && block.trim() === "") {
+    const marker = "1. ";
+    const value = text.slice(0, start) + marker + block + text.slice(end);
+    return { value, selStart: selStart + marker.length, selEnd: selEnd + marker.length };
+  }
+  const lines = block.split("\n");
+  const numberRe = /^\d+\.\s+/;
+  const allNumbered = lines.every((l) => numberRe.test(l) || l.trim() === "");
+  let n = 0;
+  const newLines = lines.map((l) => {
+    if (l.trim() === "") return l;
+    if (allNumbered) return l.replace(numberRe, "");
+    n += 1;
+    return numberRe.test(l) ? l : `${n}. ${l}`;
+  });
+  const newBlock = newLines.join("\n");
+  const value = text.slice(0, start) + newBlock + text.slice(end);
+  const deltaFirstLine = newLines[0].length - lines[0].length;
+  const deltaTotal = newBlock.length - block.length;
+  return {
+    value,
+    selStart: Math.max(start, selStart + deltaFirstLine),
+    selEnd: Math.max(start, selEnd + deltaTotal),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// enhanceNote — the "Enhance with AI" client. POSTs the note's current
+// markdown to this plugin's own `enhance` webhook (server/plugin.go), which
+// relays it through Host.InvokeUtilityAgent. host.api.fetch resolves to a
+// plain fetch Response (see apps/web/lib/plugins/host-api.ts) — it does not
+// throw on a non-2xx status, so every failure path here is driven by
+// response.ok / response.status, mirroring the "enhance prompt" feature's
+// own error handling.
+// ---------------------------------------------------------------------------
+export async function enhanceNote(host, content) {
+  let response;
+  try {
+    response = await host.api.fetch(ENHANCE_WEBHOOK_PATH, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ content }),
+    });
+  } catch {
+    const error = new Error("Could not reach the AI enhance service. Check your connection and try again.");
+    error.notConfigured = false;
+    throw error;
+  }
+
+  let data = null;
+  try {
+    data = await response.json();
+  } catch {
+    data = null;
+  }
+
+  if (!response.ok) {
+    // 412 is this webhook's distinguishable "no utility agent configured"
+    // signal (server/plugin.go, mapped from gRPC FailedPrecondition per
+    // ADR 0048) — surfaced as a clear, non-fatal message rather than a
+    // generic failure.
+    const notConfigured = response.status === 412;
+    const message = notConfigured
+      ? (data && data.error) || "No utility agent is configured for this plugin yet."
+      : (data && data.error) || `Could not enhance this note (status ${response.status}).`;
+    const error = new Error(message);
+    error.notConfigured = notConfigured;
+    error.status = response.status;
+    throw error;
+  }
+
+  if (!data || typeof data.content !== "string") {
+    const error = new Error("The AI enhance service returned an unexpected response.");
+    error.notConfigured = false;
+    throw error;
+  }
+  return data.content;
+}
+
+// ---------------------------------------------------------------------------
+// enhancePreviewReducer — the "Enhance with AI" preview/Accept/Discard state
+// machine, framework-free so it is unit-testable directly (no DOM, no
+// host.React). NotesEditor wires this via host.React.useReducer:
+//   idle -> (click Enhance) -> loading -> (success) -> preview -> (Accept
+//   or Discard) -> idle. A failure from `loading` goes to `error` (message
+//   shown inline, no note mutation); dismissing an error returns to idle.
+// The note's stored value is only ever mutated by the component's own
+// Accept handler (store.setValue), never by the reducer itself — this
+// state machine only tracks what the preview UI should show.
+// ---------------------------------------------------------------------------
+export const initialEnhanceState = { status: "idle" };
+
+export function enhancePreviewReducer(state, action) {
+  switch (action.type) {
+    case "start":
+      return { status: "loading" };
+    case "success":
+      return { status: "preview", preview: action.content };
+    case "failure":
+      return { status: "error", message: action.message, notConfigured: Boolean(action.notConfigured) };
+    case "discard":
+    case "accept":
+    case "dismiss":
+      return { status: "idle" };
+    default:
+      return state;
+  }
+}
 
 // ---------------------------------------------------------------------------
 // createNoteStore — a single task's note, independent of any UI framework.
@@ -365,6 +629,13 @@ export function disposeNoteIndicatorSubscription() {
 // still applies to the one piece of task identity this plugin does use: every
 // surface below keys off its own taskId/props.taskId, never a store-wide
 // "current task".
+//
+// presentation: "modal" gives NotesEditor its fixed-height container (see
+// below) — this was previously the surface that had to fall back to a plain
+// `<textarea>` because host.ui.RichTextEditor's ToastProvider dependency
+// isn't satisfied inside the host's PluginModalHost (a host-platform gap,
+// not fixable from this repo). Now that both surfaces share one markdown
+// editor, that gap no longer applies to either surface.
 // ---------------------------------------------------------------------------
 export function makeNoteModalContent(host, taskId) {
   return function NoteModalContent() {
@@ -373,17 +644,7 @@ export function makeNoteModalContent(host, taskId) {
       host,
       taskId,
       surfaceId: "note-modal",
-      presentation: "desktop",
-      // host.ui.RichTextEditor (TipTapPlanEditor) calls useMermaidErrorToast,
-      // which requires a ToastProvider ancestor. The host's own
-      // PluginModalHost (components/plugins/plugin-modal-host.tsx) does not
-      // render one, so mounting the rich editor here throws and the modal
-      // body goes blank (title bar only) — a host-platform gap, not
-      // something this plugin's own repo can fix. Fall back to a plain
-      // textarea for this one surface until that's addressed upstream; the
-      // task panel keeps the full rich editor, which does have a
-      // ToastProvider ancestor.
-      editorKind: "plain",
+      presentation: "modal",
     });
   };
 }
@@ -424,21 +685,84 @@ function useNoteStore(host, { taskId, surfaceId }) {
   return { snapshot, store: storeRef.current };
 }
 
-function NotesEditor({ host, taskId, surfaceId, presentation, editorKind = "rich" }) {
+// TOOLBAR_ACTIONS drives MarkdownToolbar: each entry pairs a short glyph
+// label (this bundle ships no icon set — see bookGlyph's own comment on why
+// SVGs are hand-inlined elsewhere; plain glyphs are simpler for eight small
+// buttons) with the pure transform it applies to the textarea's current
+// selection.
+const TOOLBAR_ACTIONS = [
+  { id: "bold", title: "Bold", glyph: "B", glyphStyle: { fontWeight: 700 }, apply: applyBold },
+  { id: "italic", title: "Italic", glyph: "I", glyphStyle: { fontStyle: "italic" }, apply: applyItalic },
+  { id: "heading", title: "Heading", glyph: "H", apply: (text, selStart, selEnd) => applyHeading(text, selStart, selEnd, 2) },
+  { id: "bullet-list", title: "Bullet list", glyph: "\u2022\u2261", apply: applyBulletList },
+  { id: "numbered-list", title: "Numbered list", glyph: "1.\u2261", apply: applyNumberedList },
+  { id: "link", title: "Link", glyph: "\uD83D\uDD17", apply: applyLink },
+  { id: "inline-code", title: "Inline code", glyph: "</>", apply: applyInlineCode },
+  { id: "code-block", title: "Code block", glyph: "{ }", apply: applyCodeBlock },
+];
+
+// MarkdownToolbar — the formatting toolbar (AC: bold, italic, heading,
+// bullet/numbered list, link, inline code, code block). Each button calls
+// onAction(applyFn); NotesEditor's applyTransform runs applyFn against the
+// textarea's current selection and applies the resulting value/selection.
+function MarkdownToolbar({ host, onAction, disabled }) {
+  const { jsx: h, ui } = host;
+  return h(
+    "div",
+    { role: "toolbar", "aria-label": "Formatting", style: { display: "flex", gap: "0.25rem", flexWrap: "wrap" } },
+    ...TOOLBAR_ACTIONS.map((action) =>
+      h(
+        ui.Button,
+        {
+          key: action.id,
+          type: "button",
+          variant: "ghost",
+          size: "icon",
+          className: "h-7 w-7",
+          title: action.title,
+          "aria-label": action.title,
+          "data-testid": `notes-toolbar-${action.id}`,
+          disabled,
+          onClick: () => onAction(action.apply),
+        },
+        h("span", { style: action.glyphStyle }, action.glyph),
+      ),
+    ),
+  );
+}
+
+function NotesEditor({ host, taskId, surfaceId, presentation }) {
   const { jsx: h, ui } = host;
+  const React = host.React;
   const { snapshot, store } = useNoteStore(host, { taskId, surfaceId });
+  const textareaRef = React.useRef(null);
+  const pendingSelectionRef = React.useRef(null);
+  const [enhanceState, dispatchEnhance] = React.useReducer(enhancePreviewReducer, initialEnhanceState);
+
   const isMobile = presentation === "mobile";
-  const isModal = editorKind === "plain";
+  const isModal = presentation === "modal";
   const containerStyle = isModal
-    ? // The host's PluginModalHost dialog has no fixed height of its own —
-      // it sizes to fit content — so without an explicit min-height here the
-      // modal collapses to a cramped little box instead of the spacious
-      // writing surface a "big note editor" modal should be.
-      { display: "flex", flexDirection: "column", minHeight: "60vh", padding: "0.75rem" }
+    ? // Fixed height (not a min-height) so the modal itself stops growing as
+      // content is typed — the editor below scrolls internally instead
+      // (AC: "fixed modal size with scrollable textarea").
+      { display: "flex", flexDirection: "column", height: "70vh", maxHeight: "70vh", padding: "0.75rem", overflow: "hidden" }
     : isMobile
       ? { display: "flex", flexDirection: "column", height: "100%", padding: "0.5rem" }
       : { display: "flex", flexDirection: "column", height: "100%", padding: "0.75rem" };
 
+  // Applies a pending caret/selection (set by applyTransform below) once the
+  // textarea has re-rendered with the transformed value — a plain DOM
+  // textarea does not track React-driven value changes' selection on its
+  // own, so this restores it explicitly after each store-driven update.
+  React.useEffect(() => {
+    const pending = pendingSelectionRef.current;
+    if (pending && textareaRef.current) {
+      textareaRef.current.focus();
+      textareaRef.current.setSelectionRange(pending.start, pending.end);
+      pendingSelectionRef.current = null;
+    }
+  });
+
   if (!snapshot) {
     return h("div", { style: containerStyle }, "Loading notes…");
   }
@@ -458,6 +782,38 @@ function NotesEditor({ host, taskId, surfaceId, presentation, editorKind = "rich
     return h("div", { style: containerStyle }, "Loading notes…");
   }
 
+  function applyTransform(transformFn) {
+    const el = textareaRef.current;
+    const selStart = el ? el.selectionStart : snapshot.value.length;
+    const selEnd = el ? el.selectionEnd : snapshot.value.length;
+    const result = transformFn(snapshot.value, selStart, selEnd);
+    store.setValue(result.value);
+    pendingSelectionRef.current = { start: result.selStart, end: result.selEnd };
+  }
+
+  function handleEnhanceClick() {
+    if (enhanceState.status === "loading" || !snapshot.value) return;
+    dispatchEnhance({ type: "start" });
+    enhanceNote(host, snapshot.value).then(
+      (content) => dispatchEnhance({ type: "success", content }),
+      (error) =>
+        dispatchEnhance({
+          type: "failure",
+          message: error && error.message ? error.message : "Could not enhance this note.",
+          notConfigured: Boolean(error && error.notConfigured),
+        }),
+    );
+  }
+
+  function handleAcceptEnhance() {
+    store.setValue(enhanceState.preview);
+    dispatchEnhance({ type: "accept" });
+  }
+
+  function handleDiscardEnhance() {
+    dispatchEnhance({ type: "discard" });
+  }
+
   const status = snapshot.conflict
     ? h(
         "div",
@@ -482,28 +838,126 @@ function NotesEditor({ host, taskId, surfaceId, presentation, editorKind = "rich
         )
       : null;
 
+  const isEnhancing = enhanceState.status === "loading";
+  const enhanceButton = h(
+    ui.Button,
+    {
+      type: "button",
+      variant: "ghost",
+      size: "sm",
+      onClick: handleEnhanceClick,
+      disabled: isEnhancing || !snapshot.value,
+      "aria-busy": isEnhancing,
+      "data-testid": "notes-enhance-button",
+      title: "Enhance with AI — proofread this note with your configured utility agent",
+    },
+    isEnhancing
+      ? h(ui.Spinner, { className: "h-4 w-4" })
+      : h("span", null, "\u2728 Enhance with AI"),
+  );
+
+  const enhancePreview =
+    enhanceState.status === "preview"
+      ? h(
+          "div",
+          {
+            role: "region",
+            "aria-label": "AI-enhanced preview",
+            style: {
+              border: "1px solid var(--border, #e2e8f0)",
+              borderRadius: "0.375rem",
+              padding: "0.5rem",
+              marginTop: "0.5rem",
+              display: "flex",
+              flexDirection: "column",
+              gap: "0.5rem",
+              maxHeight: "45%",
+              overflowY: "auto",
+            },
+          },
+          h("p", { style: { fontSize: "0.8rem", fontWeight: 600 } }, "AI-enhanced preview"),
+          h(ui.Textarea, {
+            value: enhanceState.preview,
+            readOnly: true,
+            className: "text-sm leading-relaxed font-mono",
+            style: { minHeight: "6rem", overflowY: "auto" },
+            "data-testid": "notes-enhance-preview",
+          }),
+          h(
+            "div",
+            { style: { display: "flex", gap: "0.5rem" } },
+            h(
+              ui.Button,
+              { type: "button", size: "sm", onClick: handleAcceptEnhance, "data-testid": "notes-enhance-accept" },
+              "Accept",
+            ),
+            h(
+              ui.Button,
+              {
+                type: "button",
+                size: "sm",
+                variant: "ghost",
+                onClick: handleDiscardEnhance,
+                "data-testid": "notes-enhance-discard",
+              },
+              "Discard",
+            ),
+          ),
+        )
+      : null;
+
+  const enhanceError =
+    enhanceState.status === "error"
+      ? h(
+          "div",
+          {
+            role: "status",
+            style: { fontSize: "0.8rem", color: "var(--destructive, #b91c1c)", marginTop: "0.25rem" },
+            "data-testid": "notes-enhance-error",
+          },
+          enhanceState.message,
+          h(
+            ui.Button,
+            { type: "button", size: "sm", variant: "ghost", onClick: () => dispatchEnhance({ type: "dismiss" }) },
+            "Dismiss",
+          ),
+        )
+      : null;
+
   return h(
     "div",
     { style: containerStyle },
-    h("p", { style: { color: "var(--muted-foreground)", fontSize: "0.8rem", marginBottom: "0.5rem" } },
-      "Private to you — only you can see this note.",
+    h(
+      "p",
+      { style: { color: "var(--muted-foreground)", fontSize: "0.8rem", marginBottom: "0.5rem" } },
+      "Private to you — only you can see this note. Using \u201cEnhance with AI\u201d sends its content to your configured utility agent.",
     ),
-    isModal
-      ? h(ui.Textarea, {
-          value: snapshot.value,
-          onChange: (e) => store.setValue(e.target.value),
-          placeholder: "Jot a note about this task…",
-          className: "flex-1 h-full min-h-0 resize-none text-sm leading-relaxed",
-          "data-testid": "notes-modal-editor",
-        })
-      : h(ui.RichTextEditor, {
-          taskId,
-          value: snapshot.value,
-          onChange: (next) => store.setValue(next),
-          placeholder: "Jot a note about this task…",
-          className: isMobile ? "flex-1 min-h-0" : "flex-1 min-h-0",
-          testId: "notes-panel-editor",
-        }),
+    h(
+      "div",
+      {
+        style: {
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "space-between",
+          gap: "0.5rem",
+          marginBottom: "0.5rem",
+          flexWrap: "wrap",
+        },
+      },
+      h(MarkdownToolbar, { host, onAction: applyTransform, disabled: isEnhancing }),
+      enhanceButton,
+    ),
+    h(ui.Textarea, {
+      ref: textareaRef,
+      value: snapshot.value,
+      onChange: (e) => store.setValue(e.target.value),
+      placeholder: "Jot a note about this task… (Markdown supported)",
+      className: "flex-1 min-h-0 resize-none text-sm leading-relaxed font-mono",
+      style: { overflowY: "auto" },
+      "data-testid": isModal ? "notes-modal-editor" : "notes-panel-editor",
+    }),
+    enhancePreview,
+    enhanceError,
     status,
   );
 }
@@ -597,9 +1051,10 @@ export function openNoteModal(host, taskId, taskTitle) {
     title: taskTitle ? `Edit notes — ${taskTitle}` : "Edit notes",
     content: makeNoteModalContent(host, taskId),
     // "xl" (sm:max-w-5xl) is the widest size PluginModalOptions offers —
-    // closest match to a spacious note-editing surface, since the host's
-    // modal has no dedicated height preset the way PR #2050's own
-    // TaskNoteEditDialog does (see NotesEditor's isModal minHeight).
+    // closest match to a spacious note-editing surface. Height is fixed by
+    // NotesEditor's own containerStyle for presentation "modal" (a fixed
+    // height, not the modal's own dialog chrome), so the modal itself never
+    // grows as the note is typed; the textarea scrolls internally instead.
     size: "xl",
   });
 }
diff --git a/ui/bundle.test.mjs b/ui/bundle.test.mjs
index aa6e9af..07d5974 100644
--- a/ui/bundle.test.mjs
+++ b/ui/bundle.test.mjs
@@ -157,6 +157,17 @@ const {
   disposeNoteIndicatorSubscription,
   makeNoteModalContent,
   openNoteModal,
+  applyBold,
+  applyItalic,
+  applyHeading,
+  applyBulletList,
+  applyNumberedList,
+  applyLink,
+  applyInlineCode,
+  applyCodeBlock,
+  enhanceNote,
+  enhancePreviewReducer,
+  initialEnhanceState,
 } = bundle;
 
 test("registers under the manifest's plugin id", () => {
@@ -253,18 +264,20 @@ test("AC11: the kanban modal surface uses the bare id 'note-modal' as its writer
   assert.equal(jsxCalls[0].props.surfaceId, "note-modal");
 });
 
-// Regression: host.ui.RichTextEditor (TipTapPlanEditor) requires a
-// ToastProvider ancestor that the host's PluginModalHost does not provide,
-// so it throws when mounted inside a plugin modal (observed live: the modal
-// renders its title bar but an empty body). The modal surface must request
-// the plain-textarea fallback so it stays editable until that host gap is
-// fixed upstream.
-test("the kanban modal surface requests the plain-textarea fallback, not host.ui.RichTextEditor", () => {
+// The kanban modal surface shares the exact same markdown editor as the
+// task panel (see the file header and makeNoteModalContent's own comment):
+// there is no more editorKind/RichTextEditor branch. presentation: "modal"
+// is the only signal NotesEditor needs to give the modal its fixed-height
+// container (AC: fixed modal size with scrollable textarea) instead of the
+// panel's height: 100%.
+test("the kanban modal surface uses presentation 'modal', the same NotesEditor as the panel", () => {
   const { host, jsxCalls } = createFakeHost();
   const NoteModalContent = makeNoteModalContent(host, "task-42");
   NoteModalContent();
 
-  assert.equal(jsxCalls[0].props.editorKind, "plain");
+  assert.equal(jsxCalls.length, 1);
+  assert.equal(jsxCalls[0].props.presentation, "modal");
+  assert.equal(jsxCalls[0].props.editorKind, undefined);
 });
 
 test("openNoteModal opens a modal bound to the given taskId, with or without a title", () => {
@@ -585,3 +598,277 @@ test("AC19: destroy() unsubscribes, clears the indicator cache, and clears pendi
     mock.timers.reset();
   }
 });
+
+// ---------------------------------------------------------------------------
+// Markdown transforms (AC3: toolbar actions insert/wrap the correct markdown
+// around the selection, or at the caret with no selection, and return an
+// updated selection).
+// ---------------------------------------------------------------------------
+
+test("applyBold wraps a selection in ** markers and keeps it selected", () => {
+  const text = "hello world";
+  // select "world"
+  const result = applyBold(text, 6, 11);
+  assert.equal(result.value, "hello **world**");
+  assert.equal(result.value.slice(result.selStart, result.selEnd), "world");
+});
+
+test("applyBold with no selection inserts a placeholder wrapped in ** and selects it", () => {
+  const result = applyBold("hello ", 6, 6);
+  assert.equal(result.value, "hello **bold text**");
+  assert.equal(result.value.slice(result.selStart, result.selEnd), "bold text");
+});
+
+test("applyItalic wraps a selection in * markers", () => {
+  const result = applyItalic("hi there", 3, 8);
+  assert.equal(result.value, "hi *there*");
+  assert.equal(result.value.slice(result.selStart, result.selEnd), "there");
+});
+
+test("applyInlineCode wraps a selection in backticks", () => {
+  const result = applyInlineCode("run npm test now", 4, 12);
+  assert.equal(result.value, "run `npm test` now");
+  assert.equal(result.value.slice(result.selStart, result.selEnd), "npm test");
+});
+
+test("applyInlineCode with no selection inserts a `code` placeholder", () => {
+  const result = applyInlineCode("", 0, 0);
+  assert.equal(result.value, "`code`");
+  assert.equal(result.value.slice(result.selStart, result.selEnd), "code");
+});
+
+test("applyCodeBlock wraps a selection in a fenced code block", () => {
+  const result = applyCodeBlock("const x = 1;", 0, 12);
+  assert.equal(result.value, "```\nconst x = 1;\n```");
+  assert.equal(result.value.slice(result.selStart, result.selEnd), "const x = 1;");
+});
+
+test("applyCodeBlock with no selection inserts a placeholder fenced block", () => {
+  const result = applyCodeBlock("", 0, 0);
+  assert.equal(result.value, "```\ncode\n```");
+});
+
+test("applyLink wraps the selection as link text and selects the url placeholder", () => {
+  const result = applyLink("see docs here", 4, 8);
+  assert.equal(result.value, "see [docs](https://) here");
+  assert.equal(result.value.slice(result.selStart, result.selEnd), "https://");
+});
+
+test("applyLink with no selection inserts placeholder link text and selects the url", () => {
+  const result = applyLink("", 0, 0);
+  assert.equal(result.value, "[link text](https://)");
+  assert.equal(result.value.slice(result.selStart, result.selEnd), "https://");
+});
+
+test("applyHeading prepends a level-2 heading marker to the current line", () => {
+  const result = applyHeading("todo list", 3, 3);
+  assert.equal(result.value, "## todo list");
+});
+
+test("applyHeading toggles the same level back off", () => {
+  const once = applyHeading("todo list", 0, 0);
+  const twice = applyHeading(once.value, once.selStart, once.selEnd);
+  assert.equal(twice.value, "todo list");
+});
+
+test("applyHeading replaces a different existing heading level", () => {
+  const result = applyHeading("# title", 2, 2, 3);
+  assert.equal(result.value, "### title");
+});
+
+test("applyHeading only affects the line containing the caret in a multi-line note", () => {
+  const text = "first line\nsecond line\nthird line";
+  const caretInSecondLine = text.indexOf("second") + 2;
+  const result = applyHeading(text, caretInSecondLine, caretInSecondLine);
+  assert.equal(result.value, "first line\n## second line\nthird line");
+});
+
+test("applyBulletList prefixes every non-blank selected line with '- '", () => {
+  const text = "milk\neggs\nbread";
+  const result = applyBulletList(text, 0, text.length);
+  assert.equal(result.value, "- milk\n- eggs\n- bread");
+});
+
+test("applyBulletList toggles the marker back off when every line already has it", () => {
+  const text = "- milk\n- eggs";
+  const result = applyBulletList(text, 0, text.length);
+  assert.equal(result.value, "milk\neggs");
+});
+
+test("applyBulletList at a bare caret (no selection) only affects that line", () => {
+  const text = "just one line";
+  const result = applyBulletList(text, 4, 4);
+  assert.equal(result.value, "- just one line");
+});
+
+test("applyBulletList at an empty note inserts a list marker", () => {
+  const result = applyBulletList("", 0, 0);
+  assert.equal(result.value, "- ");
+  assert.equal(result.selStart, 2);
+  assert.equal(result.selEnd, 2);
+});
+
+test("applyBulletList at a blank line inserts a marker for typing", () => {
+  const text = "before\n\nafter";
+  const caretOnBlankLine = "before\n".length;
+  const result = applyBulletList(text, caretOnBlankLine, caretOnBlankLine);
+  assert.equal(result.value, "before\n- \nafter");
+  assert.equal(result.selStart, caretOnBlankLine + 2);
+  assert.equal(result.selEnd, caretOnBlankLine + 2);
+});
+
+test("applyBulletList skips blank lines within the selection", () => {
+  const text = "milk\n\neggs";
+  const result = applyBulletList(text, 0, text.length);
+  assert.equal(result.value, "- milk\n\n- eggs");
+});
+
+test("applyNumberedList prefixes every non-blank selected line with sequential numbers", () => {
+  const text = "milk\neggs\nbread";
+  const result = applyNumberedList(text, 0, text.length);
+  assert.equal(result.value, "1. milk\n2. eggs\n3. bread");
+});
+
+test("applyNumberedList toggles the marker back off when every line already has it", () => {
+  const text = "1. milk\n2. eggs";
+  const result = applyNumberedList(text, 0, text.length);
+  assert.equal(result.value, "milk\neggs");
+});
+
+test("applyNumberedList at an empty note inserts a numbered marker", () => {
+  const result = applyNumberedList("", 0, 0);
+  assert.equal(result.value, "1. ");
+  assert.equal(result.selStart, 3);
+  assert.equal(result.selEnd, 3);
+});
+
+test("applyNumberedList at a blank line inserts a marker for typing", () => {
+  const text = "before\n\nafter";
+  const caretOnBlankLine = "before\n".length;
+  const result = applyNumberedList(text, caretOnBlankLine, caretOnBlankLine);
+  assert.equal(result.value, "before\n1. \nafter");
+  assert.equal(result.selStart, caretOnBlankLine + 3);
+  assert.equal(result.selEnd, caretOnBlankLine + 3);
+});
+
+// ---------------------------------------------------------------------------
+// enhanceNote — the "Enhance with AI" client (AC5/AC6/AC7).
+// ---------------------------------------------------------------------------
+
+function fakeApiHost(fetchImpl) {
+  return { api: { fetch: fetchImpl } };
+}
+
+function fakeJsonResponse(status, body) {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    json: async () => body,
+  };
+}
+
+test("enhanceNote posts the note content to webhooks/enhance and returns the improved content", async () => {
+  let capturedPath;
+  let capturedInit;
+  const host = fakeApiHost(async (path, init) => {
+    capturedPath = path;
+    capturedInit = init;
+    return fakeJsonResponse(200, { content: "improved markdown" });
+  });
+
+  const result = await enhanceNote(host, "raw markdown");
+  assert.equal(result, "improved markdown");
+  assert.equal(capturedPath, "webhooks/enhance");
+  assert.equal(capturedInit.method, "POST");
+  assert.equal(JSON.parse(capturedInit.body).content, "raw markdown");
+});
+
+test("enhanceNote maps a 412 response to a distinguishable notConfigured error", async () => {
+  const host = fakeApiHost(async () =>
+    fakeJsonResponse(412, { error: "no utility agent is configured for this plugin" }),
+  );
+
+  await assert.rejects(
+    () => enhanceNote(host, "raw markdown"),
+    (error) => {
+      assert.equal(error.notConfigured, true);
+      assert.match(error.message, /utility agent/);
+      return true;
+    },
+  );
+});
+
+test("enhanceNote surfaces other non-2xx statuses as a generic (non-notConfigured) error", async () => {
+  const host = fakeApiHost(async () => fakeJsonResponse(502, { error: "AI enhancement failed" }));
+
+  await assert.rejects(
+    () => enhanceNote(host, "raw markdown"),
+    (error) => {
+      assert.equal(error.notConfigured, false);
+      assert.equal(error.status, 502);
+      return true;
+    },
+  );
+});
+
+test("enhanceNote surfaces a network failure (fetch rejecting) as a non-notConfigured error", async () => {
+  const host = fakeApiHost(async () => {
+    throw new TypeError("Failed to fetch");
+  });
+
+  await assert.rejects(
+    () => enhanceNote(host, "raw markdown"),
+    (error) => {
+      assert.equal(error.notConfigured, false);
+      return true;
+    },
+  );
+});
+
+test("enhanceNote rejects when the success response is missing a content field", async () => {
+  const host = fakeApiHost(async () => fakeJsonResponse(200, {}));
+
+  await assert.rejects(() => enhanceNote(host, "raw markdown"));
+});
+
+// ---------------------------------------------------------------------------
+// enhancePreviewReducer — the preview/Accept/Discard state machine.
+// ---------------------------------------------------------------------------
+
+test("enhancePreviewReducer: start -> success -> accept returns to idle, preview held in between", () => {
+  let state = initialEnhanceState;
+  assert.equal(state.status, "idle");
+
+  state = enhancePreviewReducer(state, { type: "start" });
+  assert.equal(state.status, "loading");
+
+  state = enhancePreviewReducer(state, { type: "success", content: "better note" });
+  assert.equal(state.status, "preview");
+  assert.equal(state.preview, "better note");
+
+  state = enhancePreviewReducer(state, { type: "accept" });
+  assert.equal(state.status, "idle");
+});
+
+test("enhancePreviewReducer: discard returns to idle without carrying the preview forward", () => {
+  let state = enhancePreviewReducer(initialEnhanceState, { type: "start" });
+  state = enhancePreviewReducer(state, { type: "success", content: "better note" });
+  state = enhancePreviewReducer(state, { type: "discard" });
+  assert.equal(state.status, "idle");
+  assert.equal(state.preview, undefined);
+});
+
+test("enhancePreviewReducer: failure carries the message and notConfigured flag; dismiss returns to idle", () => {
+  let state = enhancePreviewReducer(initialEnhanceState, { type: "start" });
+  state = enhancePreviewReducer(state, {
+    type: "failure",
+    message: "No utility agent is configured for this plugin yet.",
+    notConfigured: true,
+  });
+  assert.equal(state.status, "error");
+  assert.equal(state.notConfigured, true);
+  assert.match(state.message, /utility agent/);
+
+  state = enhancePreviewReducer(state, { type: "dismiss" });
+  assert.equal(state.status, "idle");
+});