feat(embed): host embedded windows as owned top-level popups

Embedded apps stay top-level (borderless popup owned by our window, kept
over the host's client area) instead of WS_CHILD, so raw-input apps such as
Blender and games receive the keyboard. Foreign Win32 calls that synchronise
on the shared input queue run on a per-embed EmbeddedWindowWorker; click and
activation hand-offs follow one rule so focus never ping-pongs. main.cpp sets
AA_DontCreateNativeWidgetSiblings so a native host no longer turns every
ancestor sibling into an HWND. Adds live SendInput tests (opt-in via
NOTEPADAI_INTERACTIVE_TESTS) with a raw-input target and an optional real
Blender run.

Also: fix misc-misplaced-const in restoreExact; README mentions ask_user
forms and their note box.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: nullmastermind

README.md

@@ -10,7 +10,7 @@ You shouldn't have to leave your editor to talk to an AI, run git, or open a she
 
 NotepadAI speaks the Agent Client Protocol (ACP) over stdio. Claude Code and Codex ship as factory agents and can be edited or deleted in Settings. You can also add any other ACP-compatible agent, including Gemini, Auggie, or your own command. Agents read and write files, run terminal commands, and see your workspace context, so they work on the same code you do. Start a session from the AI menu or by right-clicking a folder in the file tree.
 
-In a chat, a finished turn folds into a single "Worked for 2m14s" row; click it to bring back the tool calls and intermediate messages. Tool calls show how long they took. Claude Code background tasks and the wake-ups or cron jobs it schedules for itself appear under the transcript, with a Stop link for tasks that can be stopped. When the agent offers `/advisor`, an Advisor checkbox in the composer turns it on and off.
+In a chat, a finished turn folds into a single "Worked for 2m14s" row; click it to bring back the tool calls and intermediate messages. Tool calls show how long they took. Claude Code background tasks and the wake-ups or cron jobs it schedules for itself appear under the transcript, with a Stop link for tasks that can be stopped. When the agent offers `/advisor`, an Advisor checkbox in the composer turns it on and off. When an agent needs a decision, its questions appear as a form in the chat with the suggested answer preselected, and a note box at the end takes anything else you want to add.
 
 There is also a Goal Agent: pick an ACP judge (Claude Code, Codex, Opencode) or a Custom API endpoint that speaks Anthropic's Messages API. You set success criteria and it drives the working agent until those criteria hold, or attach a goal to an existing conversation. Criteria presets can be saved globally, or into the current project's `.agents/.goals` folder so they travel with the repo; files already in that folder show up in the load list. A judge that needs a human action, or that hits the iteration cap with the criterion still unmet, stops and hands the criterion back instead of marking the goal done. With Prefix /goal checked, the first criterion is sent immediately when the agent supports `/goal`. If a reply is still running and the agent does not support `/goal`, that goal waits in the send queue so the current reply is not stopped. Later criteria wait until the previous is achieved. Send with Goal defaults to the agent's own `/goal` command instead: each criterion goes out on its own, with no separate judge. A `/goal` typed in the composer is sent while a turn is still running only when the agent supports that command; otherwise it waits in the queue. A goal is not judged, and auto compact does not run, while the agent still has background tasks running or a wake-up turn pending. When a goal is achieved, the session can compact automatically. Prompts sent while an agent is still working are queued and delivered when it finishes. AI chats group by project, with a session strip to switch conversations in the same dock. The composer can ask the agent to work in a new git worktree. When you commit, AI can write the commit message from your staged diff. That generator (and other LLM calls) can talk to an OpenAI-compatible endpoint or Anthropic's Messages API. Leave the commit box empty (when not amending) and Commit lets you pick an ACP agent to do the commit. Protocol details and how to wire up a custom ACP agent are in [doc/AcpAgents.md](doc/AcpAgents.md).
 

src/CMakeLists.txt

@@ -570,6 +570,8 @@ qt_add_executable(NotepadAI
 	EmbeddedWindowWin32.h
 	EmbeddedWindowWin32.cpp
 	EmbeddedWindowEnumeration.cpp
+	EmbeddedWindowWorker.h
+	EmbeddedWindowWorker.cpp
 	NativeWindowHost.h
 	NativeWindowHost.cpp
 	PendingCloseState.h
@@ -699,7 +701,7 @@ if(WIN32)
     # crypt32/dbghelp: existing deps. ws2_32: winsock for the SSH transport's
     # raw socket (Libssh2Transport.cpp calls getaddrinfo/connect/closesocket).
     # dwmapi: filters cloaked compositor windows from the Embed menu.
-    target_link_libraries(NotepadAI PRIVATE crypt32 dbghelp ws2_32 dwmapi)
+    target_link_libraries(NotepadAI PRIVATE crypt32 dbghelp ws2_32 dwmapi comctl32)
 elseif(APPLE)
     target_sources(NotepadAI PRIVATE ai/CredentialStore_Mac.mm)
     target_link_libraries(NotepadAI PRIVATE "-framework Security" "-framework CoreFoundation")

src/EmbeddedWindowController.cpp

@@ -152,6 +152,8 @@ void EmbeddedWindowController::poll()
     for (Embed *embed : snapshot) {
         if (embed->closePending || !platTargetOwnsToken(embed->state, embed->token))
             closeEmbeddedTab(embed, ReleaseMode::FailSafeDetach);
+        else
+            platTick(embed->token);
     }
     updateWatchdog();
 }

src/EmbeddedWindowController.h

@@ -93,15 +93,17 @@ class EmbeddedWindowController : public QObject
     virtual quintptr platCreateTab(quintptr token, const QString &title) = 0;
     // Tag the foreign window with `token`. False if refused/already tagged.
     virtual bool platMarkWindow(quintptr handle, quintptr token) = 0;
-    // Reparent + restyle the foreign window into the host, then attach/sync.
+    // Restyle the foreign window into a popup owned by the host's top-level and
+    // place it over the host, then attach/sync.
     virtual bool platPrepareAndAttach(quintptr token, const EmbeddedWindowWin32::NativeWindowState &state,
                                       quintptr hostHandle) = 0;
     // Read-only ownership guard: the expected target still carries our token
     // (also validates handle + pid + tid). This gates every HWND mutation.
     virtual bool platTargetOwnsToken(
         const EmbeddedWindowWin32::NativeWindowState &state, quintptr token) = 0;
-    // Read-only target-specific hierarchy guard: the expected HWND is currently
-    // a direct child of this embed's native host, independent of token state.
+    // Read-only target-specific hierarchy guard: the expected HWND is still
+    // embedded (owned by the host's top-level, so it would be destroyed with
+    // it), independent of token state.
     virtual bool platExpectedTargetAttached(
         const EmbeddedWindowWin32::NativeWindowState &state, quintptr token) = 0;
     // Read-only final destruction guard: the host still parents any live foreign
@@ -126,6 +128,9 @@ class EmbeddedWindowController : public QObject
     // Show the user the "cannot detach; tab kept open" feedback.
     virtual void platNotifyCloseVetoed() = 0;
 
+    // Periodic (watchdog) check of a live, owned embed. Default: nothing.
+    virtual void platTick(quintptr token) { Q_UNUSED(token) }
+
     // Start/stop the retry watchdog. Base impl toggles a coarse timer; override
     // is unnecessary for tests (they call poll() directly, watchdog stays idle).
     virtual void updateWatchdog();

src/EmbeddedWindowManager.cpp

@@ -30,6 +30,14 @@ EmbeddedWindowManager::EmbeddedWindowManager(DockedEditor *dockedEditor, QObject
     , m_dockedEditor(dockedEditor)
 {
     connect(m_dockedEditor, &DockedEditor::previewTabActivated, this, [this](QWidget *widget) {
+        // Choosing an embed tab gives the embed the keyboard, like an editor:
+        // Qt focus on its host, then the (coalesced) activation.
+        for (const Tab *tab : std::as_const(m_tabs)) {
+            if (tab->host && tab->host.data() == widget) {
+                widget->setFocus(Qt::OtherFocusReason);
+                break;
+            }
+        }
         m_focusRouter.request(widget);
     });
 }
@@ -86,7 +94,7 @@ quintptr EmbeddedWindowManager::platCreateTab(quintptr token, const QString &tit
     const QPointer<NativeWindowHost> hostGuard(host);
     m_focusRouter.registerHost(host, [hostGuard]() {
         if (hostGuard)
-            hostGuard->restoreForeignFocus();
+            hostGuard->activateForeign();
     });
     host->setFocusRequestCallback([managerGuard, hostGuard]() {
         if (managerGuard && hostGuard)
@@ -147,8 +155,7 @@ bool EmbeddedWindowManager::platExpectedTargetAttached(
 {
     Tab *tab = m_tabs.value(token);
     return tab && tab->host
-        && EmbeddedWindowWin32::isDirectChildOfHost(
-            state.handle, tab->host->nativeHandle());
+        && EmbeddedWindowWin32::isEmbeddedIn(state.handle, tab->host->nativeHandle());
 }
 
 bool EmbeddedWindowManager::platHostRetainsForeignChild(quintptr token)
@@ -161,13 +168,33 @@ bool EmbeddedWindowManager::platHostRetainsForeignChild(quintptr token)
 bool EmbeddedWindowManager::platRestoreExact(
     const EmbeddedWindowWin32::NativeWindowState &state, quintptr token)
 {
-    return EmbeddedWindowWin32::restoreExact(state, token);
+    Tab *tab = m_tabs.value(token);
+    if (tab && tab->host)
+        tab->host->pauseForeignCalls();
+    const bool released = EmbeddedWindowWin32::restoreExact(state, token);
+    if (!released && tab && tab->host)
+        tab->host->resumeForeignCalls();
+    return released;
 }
 
 bool EmbeddedWindowManager::platFailSafeDetach(
     const EmbeddedWindowWin32::NativeWindowState &state, quintptr token)
 {
-    return EmbeddedWindowWin32::failSafeDetach(state, token);
+    Tab *tab = m_tabs.value(token);
+    if (tab && tab->host)
+        tab->host->pauseForeignCalls();
+    const bool released = EmbeddedWindowWin32::failSafeDetach(state, token);
+    if (!released && tab && tab->host)
+        tab->host->resumeForeignCalls();
+    return released;
+}
+
+void EmbeddedWindowManager::platTick(quintptr token)
+{
+    // Self-heal geometry if the embedded app resized itself (pure reads unless
+    // the rect differs).
+    if (Tab *tab = m_tabs.value(token); tab && tab->host && tab->host->isVisible())
+        tab->host->sync();
 }
 
 void EmbeddedWindowManager::platDetachHost(quintptr token)

src/EmbeddedWindowManager.h

@@ -47,6 +47,7 @@ class EmbeddedWindowManager final : public EmbeddedWindowController
         const EmbeddedWindowWin32::NativeWindowState &state, quintptr token) override;
     bool platHostRetainsForeignChild(quintptr token) override;
     bool platRestoreExact(const EmbeddedWindowWin32::NativeWindowState &state, quintptr token) override;
+    void platTick(quintptr token) override;
     bool platFailSafeDetach(const EmbeddedWindowWin32::NativeWindowState &state, quintptr token) override;
     void platDetachHost(quintptr token) override;
     void platClearHostCallback(quintptr token) override;