dsh-codex-style-computer-use 1.2.3 → 1.3.1

package/lib/core/worker.cs

@@ -13,7 +13,7 @@
 // Safety model: the worker is a faithful actuator. Policy (approvals,
 // blacklists, masking) lives in the DSH plugin / MCP gate layers. Worker-side
 // guards: exact physical Ctrl+Esc for manual pause, event-driven human ownership,
-// and accepted-input cleanup. Physical activity yields until three seconds quiet.
+// and accepted-input cleanup. Physical takeover during actuation yields until three seconds quiet.
 
 using System;
 using System.Collections.Generic;
@@ -24,23 +24,26 @@ using System.Drawing.Imaging;
 using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.WindowsRuntime; // AsBuffer: byte[] -> WinRT IBuffer
 using System.Text;
 using System.Threading;
 using System.Web.Script.Serialization;
 using System.Windows.Automation;
 using System.Windows.Forms; // Clipboard (watch out: bare Point stays our own struct)
+// Inbox OCR (zero external dependencies): the union Windows.winmd ships in lib/core/winmd.
+using Windows.Media.Ocr;
+using Windows.Graphics.Imaging;
 
 namespace DshComputerUse.Worker
 {
-    // Monotonic, event-driven ownership. A brief touch yields immediately; two seconds
-    // of continued input/holding enters waiting. Only three seconds with no held input
-    // and no physical event returns control. Ordinary input never creates a STOP file.
+    // A live cycle observes physical holds, but only actual actuation can start a handoff.
+    // Once yielded, three quiet seconds with no held input returns control to the agent.
     public sealed class HumanInputState
     {
         public const int SustainedMs = 2000, IdleMs = 3000;
         readonly object sync = new object();
         readonly HashSet<int> held = new HashSet<int>();
-        bool enabled, seen;
+        bool enabled, acting, seen;
         string phase = "idle", lastKind = "none";
         long first, last, revision, burst;
         public string Phase { get { lock (sync) { return phase; } } }
@@ -67,20 +70,38 @@ namespace DshComputerUse.Worker
             {
                 if (enabled == on) return;
                 enabled = on;
-                if (!on) { phase = "idle"; return; }
-                if (held.Count > 0 || (seen && now - last < IdleMs)) Start(now);
+                if (!on) { phase = "idle"; acting = false; }
+            }
+        }
+        public void SetActing(bool on, long now)
+        {
+            lock (sync)
+            {
+                acting = on;
+                // Do not replay earlier ordinary activity. A key/button still physically
+                // held does need ownership before we can inject a conflicting chord.
+                if (on && enabled && phase == "idle" && held.Count > 0)
+                { last = now; revision++; Start(now); }
             }
         }
         void Start(long now) { phase = "yielding"; first = now; if (!seen) last = now; burst++; }
-        public void Record(int key, bool down, bool up, long now)
+        public void Record(int key, bool down, bool up, long now) { Record(key, down, up, now, false); }
+        /// A DELIBERATE pointer move (the 16-px tolerance in PointerHandoffTolerance has already
+        /// filtered jitter and agent motion) yields even BETWEEN actuations. Human spec
+        /// 2026-11-04: while a cycle is live, the human reaching for the mouse is a takeover no
+        /// matter whether an injection happens to be in flight at that instant — the old gate
+        /// (`idle && !acting`) only lit the yield during the few dozen milliseconds of each
+        /// click, so an interruption in the gaps showed no light at all.
+        public void Record(int key, bool down, bool up, long now, bool deliberate)
         {
             lock (sync)
             {
                 bool continued = held.Count > 0 || (seen && now - last < IdleMs);
                 lastKind = key == 0 ? "pointer-or-wheel" : key <= 6 ? "button" : "keyboard";
                 if (key != 0) { if (down) held.Add(key); if (up) held.Remove(key); }
-                seen = true; last = now; revision++;
-                if (!enabled) return;
+                seen = true; last = now;
+                if (!enabled || (phase == "idle" && !acting && !deliberate)) return;
+                revision++;
                 if (phase == "idle" || !continued) Start(now);
                 if (now - first >= SustainedMs) phase = "waiting";
             }
@@ -103,6 +124,68 @@ namespace DshComputerUse.Worker
         }
     }
 
+    // The UAC secure desktop (and the lock screen) is the ONE surface automation must never
+    // reach — Windows enforces that itself. The honest addition (human request 2026-11-04)
+    // is to NOTICE the switch, refuse to dispatch while it stands, tell the human exactly
+    // what to do, and auto-continue the moment the normal desktop is back. Detection is an
+    // OpenInputDesktop probe: while the secure desktop is up, an unprivileged thread cannot
+    // open the input desktop at all. Transitions are confirmed over consecutive misses so a
+    // single hiccup never pauses dispatch, and one success clears the state immediately.
+    public sealed class SecureDesktopWatch
+    {
+        public const int ConfirmMisses = 3;
+        readonly object sync = new object();
+        bool active; int misses;
+        public bool Active { get { lock (sync) { return active; } } }
+        /// Returns true only on a STATE TRANSITION; the caller audits and notifies those alone.
+        public bool Observe(bool reachable)
+        {
+            lock (sync)
+            {
+                if (reachable)
+                {
+                    misses = 0;
+                    if (!active) return false;
+                    active = false;
+                    return true;      // secured -> normal: dispatch may resume
+                }
+                if (active) return false;
+                if (++misses < ConfirmMisses) return false;
+                active = true;
+                return true;         // normal -> secured
+            }
+        }
+    }
+
+    // Sum only physical displacement, rebasing every injected cursor event. Agent
+    // motion cannot turn a 1-pixel hand tremor into a takeover. Back-and-forth jitter
+    // cancels rather than accumulating path length; a deliberate 16-pixel move yields.
+    public sealed class PointerHandoffTolerance
+    {
+        public const int DistancePx = 16, BurstGapMs = 250;
+        readonly object sync = new object();
+        bool seen;
+        int x, y;
+        long dx, dy, lastPhysical;
+        public void Reset(int px, int py)
+        { lock (sync) { seen = true; x = px; y = py; dx = dy = 0; lastPhysical = 0; } }
+        public bool Record(int px, int py, bool physical, bool acting, bool yielded, long now)
+        {
+            lock (sync)
+            {
+                long mx = seen ? (long)px - x : 0, my = seen ? (long)py - y : 0;
+                x = px; y = py; seen = true;
+                if (!physical) return false;
+                if (!acting && !yielded) { dx = dy = 0; lastPhysical = now; return false; }
+                if (mx == 0 && my == 0) return false;
+                if (yielded) return true;
+                if (now - lastPhysical > BurstGapMs) dx = dy = 0;
+                lastPhysical = now; dx += mx; dy += my;
+                return dx * dx + dy * dy >= DistancePx * DistancePx;
+            }
+        }
+    }
+
     // A temporary pause is an explicit, single-use claim. No clock grants permission.
     public sealed class RecoveryPermit
     {
@@ -177,7 +260,12 @@ namespace DshComputerUse.Worker
             if (!active || paused || exited) return null;
             lock (sync)
             {
-                if (hwnd == 0 || pid == 0) return "no target has been activated in this cycle";
+                if (hwnd == 0 || pid == 0)
+                {
+                    const string missing = "this worker has no confirmed target for the current cycle";
+                    if (host || foreground == 0 || process == 0) return missing;
+                    return missing + ". Observed foreground hwnd=" + foreground + ", pid=" + process;
+                }
                 if (!targetExists) return "the activated target window no longer exists";
                 if (host) return "the agent host is in front of the target window";
                 if (hwnd != foreground || pid != process) return "the foreground no longer matches the activated target";
@@ -389,6 +477,13 @@ namespace DshComputerUse.Worker
         public static extern bool DrawIconEx(IntPtr hdc, int xLeft, int yTop, IntPtr hIcon, int cxWidth, int cyHeight, int istepIfAniCur, IntPtr hbrFlickerFreeDraw, uint diFlags);
         [DllImport("user32.dll")]
         public static extern uint SendNotifyMessage(IntPtr hWnd, uint msg, IntPtr w, IntPtr l);
+        // Secure-desktop probe: while the UAC prompt (or the lock screen) is up, an unprivileged
+        // thread CANNOT open the input desktop — that refusal is the only reliable, permission-free
+        // witness that the machine switched to the surface automation must never touch.
+        [DllImport("user32.dll", SetLastError = true)]
+        public static extern IntPtr OpenInputDesktop(uint flags, bool inherit, uint access);
+        [DllImport("user32.dll")]
+        public static extern bool CloseDesktop(IntPtr h);
 
         // ---- low-level keyboard hook: the human's emergency brake ----
         public delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);
@@ -415,7 +510,7 @@ namespace DshComputerUse.Worker
         [StructLayout(LayoutKind.Sequential)]
         public struct KBDLLHOOKSTRUCT { public uint vkCode, scanCode, flags, time; public IntPtr dwExtraInfo; }
         [StructLayout(LayoutKind.Sequential)]
-        public struct NativeMsg { public IntPtr hwnd; public uint message; public IntPtr wParam, lParam; public uint time; public int ptX, ptY; }
+        public struct NativeMsg { public IntPtr hwnd; public uint message; public IntPtr wParam, lParam; public uint time; public int ptX, ptY; public uint lPrivate; }
         public const int WH_KEYBOARD_LL = 13, WM_KEYDOWN_ = 0x0100, WM_SYSKEYDOWN_ = 0x0104,
                          WM_KEYUP_ = 0x0101, WM_SYSKEYUP_ = 0x0105;
         // KBDLLHOOKSTRUCT.flags bit 4: the key did NOT come from the physical keyboard — some
@@ -455,7 +550,6 @@ namespace DshComputerUse.Worker
         [StructLayout(LayoutKind.Sequential)] struct SIZEL { public int cx, cy; }
         [StructLayout(LayoutKind.Sequential, Pack = 1)]
         struct BLENDFUNCTION { public byte BlendOp, BlendFlags, SourceConstantAlpha, AlphaFormat; }
-        [StructLayout(LayoutKind.Sequential)] struct MSG { public IntPtr hwnd; public uint message; public IntPtr wParam, lParam; public uint time; public int ptX, ptY; }
 
         [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
         static extern IntPtr CreateWindowEx(int exStyle, string cls, string name, int style,
@@ -465,49 +559,77 @@ namespace DshComputerUse.Worker
         [DllImport("user32.dll")] static extern bool SetWindowPos(IntPtr h, IntPtr after, int x, int y, int cx, int cy, uint flags);
         [DllImport("user32.dll")] static extern IntPtr GetDC(IntPtr h);
         [DllImport("user32.dll")] static extern int ReleaseDC(IntPtr h, IntPtr dc);
-        [DllImport("user32.dll")] static extern bool PeekMessage(out MSG m, IntPtr h, uint min, uint max, uint remove);
+        [DllImport("user32.dll", CharSet = CharSet.Unicode)] static extern bool PeekMessage(out Native.NativeMsg m, IntPtr h, uint min, uint max, uint remove);
+        [DllImport("user32.dll")] static extern bool ValidateRect(IntPtr h, IntPtr rect);
         [DllImport("gdi32.dll")] static extern IntPtr CreateCompatibleDC(IntPtr dc);
         [DllImport("gdi32.dll")] static extern bool DeleteDC(IntPtr dc);
         [DllImport("gdi32.dll")] static extern IntPtr SelectObject(IntPtr dc, IntPtr o);
         [DllImport("gdi32.dll")] static extern bool DeleteObject(IntPtr o);
         [DllImport("gdi32.dll")] static extern IntPtr CreateDIBSection(IntPtr dc, ref Native.BITMAPINFO bmi, uint usage, out IntPtr bits, IntPtr section, uint offset);
-        [DllImport("user32.dll")] static extern bool UpdateLayeredWindow(IntPtr h, IntPtr dst, ref POINTL pptDst, ref SIZEL psize,
+        [DllImport("user32.dll", SetLastError = true)] static extern bool UpdateLayeredWindow(IntPtr h, IntPtr dst, ref POINTL pptDst, ref SIZEL psize,
             IntPtr src, ref POINTL pptSrc, int colorKey, ref BLENDFUNCTION blend, int flags);
         [DllImport("user32.dll")] static extern int GetSystemMetrics(int i);
+        [DllImport("user32.dll")] static extern bool SetWindowDisplayAffinity(IntPtr hwnd, uint affinity);
 
         static Thread _thread;
-        static volatile int _lastTouchMs;       // 0 = never; else Environment.TickCount of the last actuation
-        static volatile int _holdMs = 900;
+        static volatile bool _acting;
+        static volatile bool _preparing;
+        static volatile int _preparationStart;
+        static int _preparationSerial, _presentedPreparation, _completedPreparation;
+        static volatile string _rendererStage = "not-started", _rendererFault;
+        static volatile int _lastLoopTick, _lastPresentTick, _lastFailedError;
+        static int _frames, _presentAttempts, _presentSuccesses, _lastAttemptWant, _lastAttemptSerial;
+        static int _lastAttemptedPreparationSerial = -1, _lastFailedSerial = -1, _lastFailedWant, _rebuiltSerial = -1;
+        public static Dictionary<string, object> Health()
+        {
+            var thread = _thread;
+            int now = Environment.TickCount;
+            return Program.Dict("workerPid", System.Diagnostics.Process.GetCurrentProcess().Id,
+                "threadAlive", thread != null && thread.IsAlive, "stage", _rendererStage, "fault", _rendererFault,
+                "want", Want, "preparationSerial", Volatile.Read(ref _preparationSerial), "presentedSerial", Volatile.Read(ref _presentedPreparation),
+                "completedSerial", Volatile.Read(ref _completedPreparation),
+                "loopAgeMs", Volatile.Read(ref _frames) == 0 ? (object)null : unchecked((uint)(now - _lastLoopTick)),
+                "presentAttempts", Volatile.Read(ref _presentAttempts), "lastAttemptWant", Volatile.Read(ref _lastAttemptWant),
+                "lastAttemptSerial", Volatile.Read(ref _lastAttemptSerial), "presentSuccesses", Volatile.Read(ref _presentSuccesses),
+                "lastAttemptedPreparationSerial", Volatile.Read(ref _lastAttemptedPreparationSerial),
+                "lastSuccessAgeMs", Volatile.Read(ref _presentSuccesses) == 0 ? (object)null : unchecked((uint)(now - _lastPresentTick)),
+                "lastFailedSerial", Volatile.Read(ref _lastFailedSerial), "lastFailedWant", Volatile.Read(ref _lastFailedWant),
+                "lastWin32Error", Volatile.Read(ref _lastFailedSerial) < 0 ? (object)null : _lastFailedError,
+                "rebuiltSerial", Volatile.Read(ref _rebuiltSerial));
+        }
+        public const int PreparationMs = 1200;   // human spec 2026-11-04: shortened from 1500 after review
         static volatile bool _enabled = true;
         static volatile string _label = "AI 正在操控此电脑 · 监听中";
 
-        /// Mark "the agent is acting right now" — the glow stays lit for holdMs afterwards.
+        /// Legacy indicator requests announce monitoring; only real input can paint deep blue.
         public static void Touch(int holdMs)
         {
             if (!_enabled) return;
-            _holdMs = holdMs < 200 ? 200 : holdMs;
-            _lastTouchMs = Environment.TickCount;
+            _thinking = true;
             EnsureStarted();
         }
-        public static void Off() { _lastTouchMs = 0; _thinking = false; }
+        public static void Off() { _acting = false; _preparing = false; _thinking = false; }
+        public static bool Acting { get { return _acting; } }
+        public static bool Preparing { get { return _preparing; } }
+        public static bool PreparationVisible { get { return _preparing && Volatile.Read(ref _presentedPreparation) == Volatile.Read(ref _preparationSerial); } }
+        public static bool PreparationComplete { get { return _preparing && Volatile.Read(ref _completedPreparation) == Volatile.Read(ref _preparationSerial); } }
+        public static void ActuationBegin() { _acting = true; EnsureStarted(); }
+        public static void ActuationEnd() { _acting = false; }
+        public static void Prepare(bool on)
+        {
+            if (!on) { _preparing = false; return; }
+            _preparationStart = 0;
+            Interlocked.Increment(ref _preparationSerial);
+            _preparing = true; _enabled = true; EnsureStarted();
+        }
 
-        // ---- "INPUT IS HAPPENING RIGHT NOW" IS A FACT, NOT A GUESS (indicator bug, 2026-09-13) ----
-        // Measured on the production build: a real move(moveDurationMs=3500) took 3823 ms, and the
-        // deep-blue ACTING border had already expired at its fixed 1200 ms hold WHILE SendInput steps
-        // were still being injected — pixels went blue at 1737 ms, then cyan/green at 2153/3438 ms with
-        // moveStillPending:true on all eight frames. Nothing here lengthens the hold: the hold is
-        // still 1200 ms. What changes is WHERE IT IS ANCHORED (the last real injection, not the moment
-        // the op began) and that an injection SEQUENCE in flight is a state the light can read.
+        // Nested injection sequences stay observable across drag/key/typing gaps.
+        // The enclosing actual action scope controls ownership and the deep-blue cue.
         static int _injecting = 0;               // refcount; Interlocked supplies the barriers
         public static void InputBegin() { Interlocked.Increment(ref _injecting); }
         public static void InputEnd() { if (Interlocked.Decrement(ref _injecting) < 0) _injecting = 0; }
         public static bool Injecting { get { return _injecting > 0; } }
-        /// Re-anchor the ACTING light on the injection itself: called from the ONE function every real
-        /// SendInput goes through, so a multi-step op (type/drag/scroll/key/animated move) stays blue
-        /// for as long as its events keep coming, and still fades on the same short tail once they
-        /// stop. The old behaviour anchored on the op's START, so any op longer than the hold went
-        /// cyan mid-flight — the "not a long think, the input is still running" report.
-        public static void KeepActing() { _lastTouchMs = Environment.TickCount; }
+        public static void KeepActing() { /* Actual operation scope owns the cue, with no trailing hold. */ }
 
         // Emergency stop must LOOK like one. The normal fade is a slow ease (~1.6 s) which,
         // during a panic, reads as "nothing happened" — so this snaps the overlay to zero on
@@ -515,7 +637,7 @@ namespace DshComputerUse.Worker
         static volatile bool _killNow = false;
         public static void Kill()
         {
-            _lastTouchMs = 0; _thinking = false; _flashStart = 0;
+            _acting = false; _preparing = false; _thinking = false; _flashStart = 0;
             _killNow = true;
         }
 
@@ -567,7 +689,7 @@ namespace DshComputerUse.Worker
         public static int DeriveWant(bool flashOn, int committed)
         {
             if (Panic.Exited) return 0;
-            return _askMode ? 5 : (_stoppedMode ? 4 : (Panic.HumanActive ? 6 : (flashOn ? 2 : committed)));
+            return _askMode ? 5 : (_stoppedMode ? 4 : (Panic.HumanActive ? 6 : (_preparing ? 7 : (Acting ? 1 : (flashOn ? 2 : committed)))));
         }
         /// The title states the same fact as the light, derived the same way (an ended session must
         /// not advertise "已暂停 · Ctrl+Alt+R 继续" in the window list).
@@ -575,7 +697,7 @@ namespace DshComputerUse.Worker
         {
             if (Panic.Exited) return "AI 已停止操控 · 未监听";
             return _askMode ? "AI 正在提问 · 在 DSH 聊天里回答 · 无倒计时（Ctrl+Alt+R 撤销）"
-                : (_stoppedMode ? "已暂停 · Ctrl+Alt+R 继续 · Ctrl+Alt+Q 退出" : Panic.HumanActive ? "已让出键鼠 · 等待人操作 · 静默 3 秒后继续" : label);
+                : (_stoppedMode ? "已暂停 · Ctrl+Alt+R 继续 · Ctrl+Alt+Q 退出" : Panic.HumanActive ? "已让出键鼠 · 等待人操作 · 静默 3 秒后继续" : _preparing ? "即将开始操作，请暂停键鼠 · 1.2 秒准备" : label);
         }
         static volatile string _shownTitle = null;
         // What the indicator is ACTUALLY rendering right now, readable from outside via `probe`.
@@ -589,14 +711,9 @@ namespace DshComputerUse.Worker
         static extern bool SetWindowText(IntPtr h, string text);
         public static void Stopped(bool on)
         {
+            // Only the window owner sets the title (in Run). A physical brake must
+            // never wait for WM_SETTEXT to be serviced by the overlay thread.
             _stoppedMode = on;
-            // The overlay's WINDOW TITLE is part of the text channel: renaming it means any
-            // window list — the agent's own computer_windows, or a human's Task Manager —
-            // states plainly that the session is stopped, with no screenshot required.
-            if (_hwnd != IntPtr.Zero)
-            {
-                try { SetWindowText(_hwnd, on ? "已暂停 · Ctrl+Alt+R 继续 · Ctrl+Alt+Q 退出" : _label); } catch { }
-            }
         }
 
         /// Mark "the agent just captured the screen": a yellow border flashes around the
@@ -663,37 +780,90 @@ namespace DshComputerUse.Worker
 
         static void ThreadProc()
         {
-            try { Run(); } catch { /* the indicator must never break actuation */ }
+            try { Run(); }
+            catch (Exception ex)
+            {
+                _rendererFault = _rendererStage + ": " + ex.Message;
+                Program.AuditRecord("GLOW-RENDER-ERROR", _rendererFault);
+            }
+            finally
+            {
+                _rendererStage = "stopped";
+                lock (typeof(Glow)) { _thread = null; }
+            }
+        }
+
+        static void PumpOverlayMessages(IntPtr hwnd)
+        {
+            _rendererStage = "message-pump";
+            const uint WM_PAINT = 0x000F;
+            Native.NativeMsg msg;
+            for (int i = 0; i < 32 && PeekMessage(out msg, hwnd, 0, 0, PM_REMOVE); i++)
+            {
+                // UpdateLayeredWindow provides all pixels. WM_PAINT stays pending
+                // until its update region is validated, even with PM_REMOVE.
+                if (msg.message == WM_PAINT) ValidateRect(msg.hwnd, IntPtr.Zero);
+                else Native.DispatchMessage(ref msg);
+            }
         }
 
         static void Run()
         {
+            while (RenderOverlay()) { } // Rebuild at most once per unpresented preparation.
+        }
+
+        static bool RenderOverlay()
+        {
+            _rendererFault = null;
+            _rendererStage = "display-metrics";
             int vx = GetSystemMetrics(Native.SM_XVIRTUALSCREEN);
             int vy = GetSystemMetrics(Native.SM_YVIRTUALSCREEN);
             int vw = GetSystemMetrics(Native.SM_CXVIRTUALSCREEN);
             int vh = GetSystemMetrics(Native.SM_CYVIRTUALSCREEN);
-            if (vw <= 0 || vh <= 0) return;
+            if (vw <= 0 || vh <= 0) throw new InvalidOperationException("empty virtual desktop");
 
+            _rendererStage = "create-window";
             IntPtr hwnd = CreateWindowEx(
                 WS_EX_LAYERED | WS_EX_TRANSPARENT | WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE | WS_EX_TOPMOST,
                 "STATIC", _label, WS_POPUP, vx, vy, vw, vh, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
-            if (hwnd == IntPtr.Zero) return;
-            _hwnd = hwnd;
-
-            IntPtr screenDc = GetDC(IntPtr.Zero);
-            IntPtr memDc = CreateCompatibleDC(screenDc);
-            Native.BITMAPINFO bmi = new Native.BITMAPINFO();
-            bmi.bmiHeader.biSize = (uint)Marshal.SizeOf(typeof(Native.BITMAPINFOHEADER));
-            bmi.bmiHeader.biWidth = vw;
-            bmi.bmiHeader.biHeight = -vh;          // top-down
-            bmi.bmiHeader.biPlanes = 1;
-            bmi.bmiHeader.biBitCount = 32;
-            bmi.bmiHeader.biCompression = 0;
-            IntPtr bits;
-            IntPtr dib = CreateDIBSection(screenDc, ref bmi, 0, out bits, IntPtr.Zero, 0);
-            if (dib == IntPtr.Zero) { DeleteDC(memDc); ReleaseDC(IntPtr.Zero, screenDc); return; }
-            IntPtr oldBmp = SelectObject(memDc, dib);
+            if (hwnd == IntPtr.Zero) throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error());
+            IntPtr screenDc = IntPtr.Zero, memDc = IntPtr.Zero, dib = IntPtr.Zero, oldBmp = IntPtr.Zero;
+            try
+            {
+                TryExcludeOverlayFromCapture(hwnd);
+                _hwnd = hwnd;
+                _rendererStage = "create-surface";
+                screenDc = GetDC(IntPtr.Zero);
+                if (screenDc == IntPtr.Zero) throw new InvalidOperationException("GetDC failed");
+                memDc = CreateCompatibleDC(screenDc);
+                if (memDc == IntPtr.Zero) throw new InvalidOperationException("CreateCompatibleDC failed");
+                Native.BITMAPINFO bmi = new Native.BITMAPINFO();
+                bmi.bmiHeader.biSize = (uint)Marshal.SizeOf(typeof(Native.BITMAPINFOHEADER));
+                bmi.bmiHeader.biWidth = vw;
+                bmi.bmiHeader.biHeight = -vh;          // top-down
+                bmi.bmiHeader.biPlanes = 1;
+                bmi.bmiHeader.biBitCount = 32;
+                IntPtr bits;
+                dib = CreateDIBSection(screenDc, ref bmi, 0, out bits, IntPtr.Zero, 0);
+                if (dib == IntPtr.Zero) throw new InvalidOperationException("CreateDIBSection failed");
+                oldBmp = SelectObject(memDc, dib);
+                if (oldBmp == IntPtr.Zero || oldBmp == new IntPtr(-1)) throw new InvalidOperationException("SelectObject failed");
+                _rendererStage = "rendering";
+                return RenderFrames(hwnd, screenDc, memDc, bits, vx, vy, vw, vh);
+            }
+            finally
+            {
+                _hwnd = IntPtr.Zero; _shownTitle = null;
+                if (oldBmp != IntPtr.Zero && oldBmp != new IntPtr(-1)) SelectObject(memDc, oldBmp);
+                if (dib != IntPtr.Zero) DeleteObject(dib);
+                if (memDc != IntPtr.Zero) DeleteDC(memDc);
+                if (screenDc != IntPtr.Zero) ReleaseDC(IntPtr.Zero, screenDc);
+                DestroyWindow(hwnd);
+            }
+        }
 
+        static bool RenderFrames(IntPtr hwnd, IntPtr screenDc, IntPtr memDc, IntPtr bits, int vx, int vy, int vw, int vh)
+        {
             POINTL dst = new POINTL(); dst.x = vx; dst.y = vy;
             POINTL src = new POINTL(); src.x = 0; src.y = 0;
             SIZEL size = new SIZEL(); size.cx = vw; size.cy = vh;
@@ -701,48 +871,32 @@ namespace DshComputerUse.Worker
             // ---- state machine with dwell hysteresis (no strobing) ----
             int curBitmap = 0;      // 0 = none, 1 = blue border, 2 = yellow flash
             int paintedFlash = 0;
+            int lastPreparationPaint = 0;
             int alpha = 0;
             bool visible = false;
-            int committed = 0;      // 0 idle / 1 acting / 3 thinking, committed after a dwell
-            int pending = -1;
-            int pendingSince = 0;
+            int committed = 0;
             while (true)
             {
-                // ACTING = input in flight (a sequence, across its sleeps) OR the short tail after the
-                // last injection. Never "a longer guess": the hold is unchanged and the tail still ends.
-                bool acting = _enabled && (Injecting ||
-                    (_lastTouchMs != 0 && unchecked(Environment.TickCount - _lastTouchMs) < _holdMs));
+                _lastLoopTick = Environment.TickCount;
+                _rendererStage = "rendering";
+                Interlocked.Increment(ref _frames);
+                // Ownership and deep blue use the same actual action scope. There is no
+                // delayed onset or lingering tail during reading, thinking or preparation.
+                bool acting = _enabled && Acting;
                 bool thinking = ThinkingActive;
                 bool flashOn = _flashStart != 0 && unchecked(Environment.TickCount - _flashStart) < _flashMs;
 
-                int live = acting ? 1 : (thinking ? 3 : 0);
-                // The flash is an OVERRIDE, never a state that lingers.
-                //
-                // 2026-09-13: the flash used to write `committed = 2`, so once it ended the dwell
-                // hysteresis (600 ms) held the yellow bitmap on screen — with the border snapped to
-                // full alpha that read as "the yellow frame is permanently lit", and the human lost
-                // the ability to tell WHICH step took a screenshot. Now yellow shows only while the
-                // flash is actually running (<=400 ms) and the border drops straight back to deep
-                // blue when acting, or pale breathing when thinking.
-                if (!flashOn)
-                {
-                    if (live != committed)
-                    {
-                        // require a state to hold for 600 ms before switching: kills strobe
-                        if (pending != live) { pending = live; pendingSince = Environment.TickCount; }
-                        else if (unchecked(Environment.TickCount - pendingSince) >= 600) { committed = live; pending = -1; }
-                    }
-                    else { pending = -1; }
-                }
+                committed = acting ? 1 : (thinking ? 3 : 0);
 
                 // ONE derivation (Glow.DeriveWant): the exit flag outranks ask/stop/flash/committed,
                 // so no later state change on another thread can paint a light on an ended session.
+                int preparationSerial = Volatile.Read(ref _preparationSerial);
                 int want = DeriveWant(flashOn, committed);
                 _want = want;            // publish it: the state the light is showing, as a fact
 
                 // Keep the overlay's WINDOW TITLE in sync with the state, from the render loop.
-                // 2026-09-13: the title was only written by Stopped(), which runs BEFORE this thread
-                // creates the window — so a process that INHERITED a stop (SyncFromFile at startup)
+                // When the title was only written by Stopped(), a process that INHERITED a stop
+                // before this thread created the window (SyncFromFile at startup)
                 // showed a red border with the title "AI 正在操控此电脑". The title is the text
                 // channel the agent and the human both read, so a lying title is worse than none.
                 // It is derived from the same flags (Glow.DeriveTitle) and a hidden window still has
@@ -760,14 +914,14 @@ namespace DshComputerUse.Worker
                     _killNow = false;
                     alpha = 0;
                     if (visible) { ShowWindow(hwnd, SW_HIDE); visible = false; }
-                    curBitmap = 0; committed = 0; pending = -1; paintedFlash = 0;
-                    MSG mk; while (PeekMessage(out mk, hwnd, 0, 0, PM_REMOVE)) { }
+                    curBitmap = 0; committed = 0; paintedFlash = 0;
+                    PumpOverlayMessages(hwnd);
                     Thread.Sleep(12);
                     continue;
                 }
                 // want: 0 idle | 1 acting (deep blue) | 3 thinking (pale blue) | 2 flash (yellow)
                 //       4 emergency-stopped (RED, steady — the session is dead until re-armed)
-                int needBitmap = want == 6 ? 5 : want == 2 ? 2 : (want == 0 ? curBitmap : (want == 1 ? 3 : (want == 4 || want == 5 ? 4 : 1)));
+                int needBitmap = want == 7 ? 6 : want == 6 ? 5 : want == 2 ? 2 : (want == 0 ? curBitmap : (want == 1 ? 3 : (want == 4 || want == 5 ? 4 : 1)));
                 // A REPAINT MUST REACH THE SCREEN EVEN WHEN ALPHA DOES NOT MOVE.
                 //
                 // The present below used to be gated on `diff != 0` alone, while the flash snaps
@@ -778,7 +932,15 @@ namespace DshComputerUse.Worker
                 // RED frame when the border happened to be at full alpha already — whether the
                 // brake was visible was luck. Present when EITHER the bitmap or the alpha changed.
                 bool repaint = false;
-                if (needBitmap == 2 && paintedFlash != _flashStart) { PaintFlash(bits, vw, vh); paintedFlash = _flashStart; curBitmap = 2; alpha = 204; repaint = true; /* snap ON at 80%: a flash is an event, not a fade */ }
+                int preparationElapsed = -1;
+                if (want == 7 && (curBitmap != 6 || !PreparationVisible || unchecked(Environment.TickCount - lastPreparationPaint) >= 50))
+                {
+                    lastPreparationPaint = Environment.TickCount;
+                    preparationElapsed = PreparationVisible ? unchecked(lastPreparationPaint - _preparationStart) : 0;
+                    PaintPreparation(bits, vw, vh, preparationElapsed);
+                    curBitmap = 6; repaint = true;
+                }
+                else if (needBitmap == 2 && paintedFlash != _flashStart) { PaintFlash(bits, vw, vh); paintedFlash = _flashStart; curBitmap = 2; alpha = 204; repaint = true; /* snap ON at 80%: a flash is an event, not a fade */ }
                 else if (needBitmap == 5 && curBitmap != 5) { PaintHumanYield(bits, vw, vh); curBitmap = 5; repaint = true; }
                 else if (needBitmap == 4 && curBitmap != 4) { PaintStop(bits, vw, vh); curBitmap = 4; repaint = true; }
                 else if (needBitmap == 3 && curBitmap != 3) { PaintBlue(bits, vw, vh, true); curBitmap = 3; repaint = true; }
@@ -790,7 +952,7 @@ namespace DshComputerUse.Worker
                 int target;
                 bool flashFrame = false;
                 bool breathFrame = false;      // breathing states are ABSOLUTE, never eased
-                if (want == 0) target = 0;
+                if (want == 0) { target = 0; breathFrame = true; }
                 else if (want == 2)
                 {
                     // The capture cue runs its OWN envelope (wind-up, burst, short fade): an absolute
@@ -798,7 +960,8 @@ namespace DshComputerUse.Worker
                     target = FlashAlpha(unchecked(Environment.TickCount - _flashStart));
                     flashFrame = true;
                 }
-                else if (want == 1) target = FULL;
+                else if (want == 1) { target = FULL; breathFrame = true; }
+                else if (want == 7) { target = 255; breathFrame = true; }
                 else if (want == 4) target = FULL;         // steady red, no breathing
                 else if (want == 6)
                 {
@@ -808,22 +971,23 @@ namespace DshComputerUse.Worker
                 else if (want == 5)
                 {
                     // ASK: red like a stop, but at TWICE the cyan breath rate (1250 ms vs 2500 ms)
-                    // and FULL SWING 0..100, so the pulse is unmistakable at a glance.
+                    // and a full swing — so the pulse is unmistakable at a glance. Human spec
+                    // 2026-11-04, raised the same day after review: the first floor (25) still
+                    // read as too dim at the trough; the whole band moved up to 50..140.
                     double askPhase = (Environment.TickCount % 1250) / 1250.0;
-                    target = 50 + (int)(Math.Sin(askPhase * 2 * Math.PI) * 50);
+                    target = 95 + (int)(Math.Sin(askPhase * 2 * Math.PI) * 45);
                     breathFrame = true;
                 }
                 else
                 {
                     // Faint blue "thinking", breathing so a still screen still shows life.
                     // 2.5 s cycle = 20% faster than the original 3.0 s.
-                    // FULL SWING 0..100 (human spec 2026-09-12). The old 58..104 band was chosen so
-                    // the trough never read as "the agent went away" — but between the damped band
-                    // and the easing below, the border barely moved at all, which is strictly worse:
-                    // a border that is always faintly there says nothing. 0 at the trough is the
-                    // point: the ring INHALES and goes dark, then comes back.
+                    // Human spec 2026-11-04, raised the same day after review: the first floor
+                    // (25) still read as "going dark" at the trough; the whole band moved up to
+                    // 50..140 — the halo stays clearly visible at its dimmest while the breathing
+                    // contrast (swing 90) is preserved.
                     double phase = (Environment.TickCount % 2500) / 2500.0;
-                    target = 50 + (int)(Math.Sin(phase * 2 * Math.PI) * 50);
+                    target = 95 + (int)(Math.Sin(phase * 2 * Math.PI) * 45);
                     breathFrame = true;
                 }
 
@@ -860,156 +1024,225 @@ namespace DshComputerUse.Worker
                             SetWindowPos(hwnd, new IntPtr(-1), vx, vy, vw, vh, 0x0004 | 0x0010 | 0x0040);
                             visible = true;
                         }
-                        UpdateLayeredWindow(hwnd, screenDc, ref dst, ref size, memDc, ref src, 0, ref bf, ULW_ALPHA);
+                        _rendererStage = "presenting";
+                        Volatile.Write(ref _lastAttemptWant, want);
+                        Volatile.Write(ref _lastAttemptSerial, preparationSerial);
+                        if (want == 7) Volatile.Write(ref _lastAttemptedPreparationSerial, preparationSerial);
+                        Interlocked.Increment(ref _presentAttempts);
+                        bool presented = UpdateLayeredWindow(hwnd, screenDc, ref dst, ref size, memDc, ref src, 0, ref bf, ULW_ALPHA);
+                        int nativeError = presented ? 0 : Marshal.GetLastWin32Error();
+                        if (presented)
+                        {
+                            _lastPresentTick = Environment.TickCount;
+                            Interlocked.Increment(ref _presentSuccesses);
+                        }
+                        else
+                        {
+                            bool firstFailure = Volatile.Read(ref _lastFailedSerial) != preparationSerial;
+                            _lastFailedError = nativeError;
+                            Volatile.Write(ref _lastFailedWant, want);
+                            Volatile.Write(ref _lastFailedSerial, preparationSerial);
+                            if (firstFailure) Program.AuditRecord("GLOW-PRESENT-FAILED", "serial=" + preparationSerial + "; want=" + want + "; win32=" + nativeError);
+                            if (want == 7 && !PreparationVisible && Volatile.Read(ref _rebuiltSerial) != preparationSerial)
+                            {
+                                Volatile.Write(ref _rebuiltSerial, preparationSerial);
+                                return true;
+                            }
+                        }
+                        if (presented && want == 7 && !PreparationVisible)
+                        {
+                            _preparationStart = Environment.TickCount;
+                            Volatile.Write(ref _presentedPreparation, preparationSerial);
+                        }
+                        if (presented && want == 7 && preparationElapsed >= PreparationMs)
+                            Volatile.Write(ref _completedPreparation, preparationSerial);
                     }
                     else if (visible) { ShowWindow(hwnd, SW_HIDE); visible = false; }
                 }
-                MSG m;
-                while (PeekMessage(out m, hwnd, 0, 0, PM_REMOVE)) { }
+                PumpOverlayMessages(hwnd);
                 Thread.Sleep(16);
             }
         }
 
-        /// The agent's activity border, in two clearly different states.
-        ///
-        /// 2026-09-12 (human request): the two states no longer share a width, and they no longer
-        /// share a hue. "thinking" is now a WIDER CYAN halo and "acting" a NARROWER DEEP BLUE one,
-        /// so the pair reads unambiguously: an outer cyan ring breathing = the agent is thinking
-        /// (it has not touched the machine yet), the inner steady blue = it is driving right now.
-        /// The old design made them the same shape and the same hue at different densities, which
-        /// is exactly the case where "is it doing something?" becomes a guess.
-        ///
-        /// Drawn as N concentric rounded-rect strokes whose alpha follows (1-t)^1.8 — a
-        /// hand-rolled gradient guaranteed to reach alpha 0 at the INNER edge (a residual
-        /// tint there read as a hard seam against near-black windows).
-        static void PaintBlue(IntPtr bits, int w, int h, bool intense)
+        // Thin, square screen-edge rails leave the application itself completely clear.
+        // Each pixel belongs to exactly one inset ring: corners meet without gaps or
+        // overlapping hot spots. Human request 2026-11-04, doubled the same day after
+        // review: the bloom must span 1.6 cm of physical screen for every colour, not
+        // the old fixed eight pixels (which read as a hairline on a 2560x1600 panel at
+        // 175%), so the ring count below is derived from the overlay window's own DPI:
+        // ~60 rings at 96 dpi, ~106 at 168.
+        static int EdgeRailThickness()
+        {
+            // Offscreen painting (visual fixtures) has no window; GetDpiForWindow then
+            // fails and the 96-dpi fallback keeps the fixture geometry deterministic.
+            uint dpi = 96;
+            IntPtr window = _hwnd;
+            if (window != IntPtr.Zero)
+            {
+                uint live = Native.GetDpiForWindow(window);
+                if (live > 0) dpi = live;
+            }
+            int rings = (int)Math.Round(1.6 / 2.54 * dpi);   // 1.6 cm in this panel's pixels
+            return Math.Max(8, Math.Min(rings, 192));
+        }
+
+        // The fixed eight-ring ramp was {244,216,94,53,30,16,8,3}: two bright core
+        // rings, then a falloff to near zero. Same profile here, stretched over the
+        // DPI-derived width: ring 0-1 keep their core alpha, rings 2..n-1 decay
+        // geometrically from 94 down to ~3 at the innermost ring.
+        static int EdgeRailAlpha(int ring, int rings)
         {
-            WithGraphics(bits, w, h, delegate (System.Drawing.Graphics g)
-            {
-                // Width and intensity are both scaled from ONE place per state, and the layered
-                // window's constant alpha does the intensity: perceived brightness = bitmap alpha x
-                // layer alpha, so scaling BOTH would give 0.64 where the human asked for 0.8.
-                // (2026-09-13: "all frames 80% as dense, 80% as wide".)
-                // The CAP has to carry the width: at 1600p the cap is what binds, so a divisor
-                // change alone moves nothing (min(46, 1600/26) == min(46, 1600/32) == 46).
-                //   acting  : 37 px  (80% of the original 46) — stays INSIDE the thinking ring
-                //   thinking: 52 px  (~40% wider)              — reaches OUTSIDE it
-                int band = intense
-                    ? Math.Max(22, Math.Min(37, Math.Min(w, h) / 32))
-                    : Math.Max(30, Math.Min(52, Math.Min(w, h) / 23));
-                int r = band + 10;
-                int peak = intense ? 240 : 168;
-                System.Drawing.Color col = intense
-                    ? System.Drawing.Color.FromArgb(255, 46, 132, 255)     // deep, saturated blue
-                    : System.Drawing.Color.FromArgb(255, 34, 226, 240);    // cyan halo (thinking)
-                const int N = 60;
-                float step = (float)band / N;
-                for (int i = 0; i < N; i++)
+            if (ring == 0) return 244;
+            if (ring == 1) return 216;
+            return (int)Math.Round(94 * Math.Pow(3.0 / 94.0, (double)(ring - 2) / (rings - 3)));
+        }
+
+        static void PaintEdgeRail(System.Drawing.Graphics g, Rectangle bounds, Color tint)
+        {
+            int rings = EdgeRailThickness();
+            var smoothing = g.SmoothingMode;
+            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.None;
+            try
+            {
+                for (int i = 0; i < rings; i++)
                 {
-                    double t = (double)i / N;
-                    int a = (int)Math.Round(peak * Math.Pow(1 - t, intense ? 2.0 : 1.8));
-                    if (a <= 0) continue;
-                    float inset = i * step;
-                    using (System.Drawing.Pen pen = new System.Drawing.Pen(
-                               System.Drawing.Color.FromArgb(a, col.R, col.G, col.B), step + 1.2f))
+                    int alpha = EdgeRailAlpha(i, rings);
+                    int x = bounds.Left + i, y = bounds.Top + i;
+                    int width = bounds.Width - 2 * i, height = bounds.Height - 2 * i;
+                    if (width <= 0 || height <= 0) break;
+                    Color start = Color.FromArgb(alpha, Math.Min(255, tint.R + 18), Math.Min(255, tint.G + 14), Math.Min(255, tint.B + 8));
+                    Color end = Color.FromArgb(alpha, tint.R, tint.G, tint.B);
+                    using (var brush = new System.Drawing.Drawing2D.LinearGradientBrush(
+                        new RectangleF(bounds.X, bounds.Y, Math.Max(1, bounds.Width), Math.Max(1, bounds.Height)), start, end, 32f))
                     {
-                        System.Drawing.Drawing2D.GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath();
-                        AddRound(path, inset, inset, w - inset * 2, h - inset * 2, Math.Max(1, r - inset));
-                        g.DrawPath(pen, path);
-                        path.Dispose();
+                        g.FillRectangle(brush, x, y, width, 1);
+                        if (height > 1) g.FillRectangle(brush, x, y + height - 1, width, 1);
+                        if (height > 2)
+                        {
+                            g.FillRectangle(brush, x, y + 1, 1, height - 2);
+                            if (width > 1) g.FillRectangle(brush, x + width - 1, y + 1, 1, height - 2);
+                        }
                     }
                 }
-                PaintEscBadge(g, intense ? 238 : 148);
+            }
+            finally { g.SmoothingMode = smoothing; }
+        }
+
+        static Rectangle OverlayDisplay(int w, int h)
+        {
+            var display = new Rectangle(0, 0, w, h);
+            if (w == Native.GetSystemMetrics(Native.SM_CXVIRTUALSCREEN) && h == Native.GetSystemMetrics(Native.SM_CYVIRTUALSCREEN))
+            {
+                display = Screen.PrimaryScreen.Bounds;
+                display.Offset(-Native.GetSystemMetrics(Native.SM_XVIRTUALSCREEN), -Native.GetSystemMetrics(Native.SM_YVIRTUALSCREEN));
+            }
+            return display;
+        }
+
+        // WDA_EXCLUDEFROMCAPTURE must not be sent on older Windows, where its fallback
+        // can black out the covered image. Unsupported APIs simply leave the overlay visible.
+        static void TryExcludeOverlayFromCapture(IntPtr hwnd)
+        {
+            try
+            {
+                object build = Microsoft.Win32.Registry.GetValue(
+                    @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion", "CurrentBuildNumber", null);
+                int number;
+                if (int.TryParse(Convert.ToString(build), out number) && number >= 19041)
+                    SetWindowDisplayAffinity(hwnd, 0x00000011);
+            }
+            catch { /* display preference only; never changes control or capture behavior */ }
+        }
+
+        static void PaintBlue(IntPtr bits, int w, int h, bool intense)
+        {
+            WithGraphics(bits, w, h, delegate(System.Drawing.Graphics g) {
+                PaintEdgeRail(g, new Rectangle(0, 0, w, h), intense
+                    ? Color.FromArgb(49, 116, 248) : Color.FromArgb(36, 206, 216));
             });
         }
 
-        /// Semi-transparent badge in the top-left corner. The human must be able to SEE that a
-        /// brake exists (and whether it is currently on) — a brake nobody can see feels exactly
-        /// like no brake at all.
         public static int HumanYieldAlpha(int tick)
-        { return 48 + (int)Math.Round(30 * (1 - Math.Cos((unchecked((uint)tick) % 2800) * 2 * Math.PI / 2800.0))); }
+        { return 90 + (int)Math.Round(35 * (1 - Math.Cos((unchecked((uint)tick) % 2800) * 2 * Math.PI / 2800.0))); }
         static void PaintHumanYield(IntPtr bits, int w, int h)
         {
             WithGraphics(bits, w, h, delegate(System.Drawing.Graphics g) {
-                int band = Math.Max(20, Math.Min(40, Math.Min(w, h) / 30));
-                for (int i = 0; i < 48; i++)
-                {
-                    float inset = (float)i * band / 48;
-                    int alpha = (int)(175 * Math.Pow(1 - i / 48.0, 1.8));
-                    using (var pen = new Pen(Color.FromArgb(alpha, 255, 231, 151), band / 48f + 1.2f))
-                    using (var shape = new System.Drawing.Drawing2D.GraphicsPath())
-                    { AddRound(shape, inset, inset, w - 2 * inset, h - 2 * inset, Math.Max(1, band + 8 - inset)); g.DrawPath(pen, shape); }
-                }
-                PaintBadge(g, "已让出键鼠 · 静默 3 秒后继续 · Ctrl+Esc 暂停", 175, false);
+                Color tint = Color.FromArgb(238, 190, 102);
+                PaintEdgeRail(g, new Rectangle(0, 0, w, h), tint);
+                PaintStatusChip(g, w, h, "已让出键鼠 · 静默 3 秒后接续", tint);
             });
         }
 
-        static void PaintEscBadge(System.Drawing.Graphics g, int opacity)
+        static void PaintPreparation(IntPtr bits, int w, int h, int elapsed)
         {
-            PaintBadge(g, "监听中 · Ctrl+Esc 暂停 · Ctrl+Alt+Q 退出", opacity, false);
+            WithGraphics(bits, w, h, delegate(System.Drawing.Graphics g) {
+                Color tint = Color.FromArgb(166, 139, 250);
+                PaintEdgeRail(g, new Rectangle(0, 0, w, h), tint);
+                Rectangle display = OverlayDisplay(w, h);
+                float scale = Math.Max(1f, Math.Min(1.25f, display.Width / 1920f));
+                float bw = Math.Min(408 * scale, display.Width - 24), bh = 64 * scale;
+                float x = display.Left + (display.Width - bw) / 2, y = display.Top + 10 * scale;
+                float progress = Math.Max(0f, Math.Min(1f, elapsed / (float)PreparationMs));
+                using (var shape = new System.Drawing.Drawing2D.GraphicsPath())
+                using (var fill = new System.Drawing.Drawing2D.LinearGradientBrush(new RectangleF(x, y, bw, bh),
+                    Color.FromArgb(224, 23, 27, 39), Color.FromArgb(224, 35, 31, 53), 0f))
+                using (var outline = new Pen(Color.FromArgb(110, tint), 1f))
+                using (var title = new Font("Microsoft YaHei UI", 12.5f * scale, FontStyle.Bold))
+                using (var detail = new Font("Microsoft YaHei UI", 9f * scale))
+                using (var white = new SolidBrush(Color.FromArgb(255, 246, 247, 253)))
+                using (var soft = new SolidBrush(Color.FromArgb(238, 183, 188, 207)))
+                using (var ring = new Pen(Color.FromArgb(70, tint), 2 * scale))
+                using (var accent = new Pen(Color.FromArgb(245, tint), 2 * scale))
+                using (var track = new SolidBrush(Color.FromArgb(52, tint)))
+                using (var bar = new System.Drawing.Drawing2D.LinearGradientBrush(
+                    new RectangleF(x + 48 * scale, y + 56 * scale, bw - 64 * scale, 2 * scale),
+                    Color.FromArgb(220, 167, 139, 250), Color.FromArgb(235, 96, 165, 250), 0f))
+                {
+                    AddRound(shape, x, y, bw, bh, 14 * scale); g.FillPath(fill, shape); g.DrawPath(outline, shape);
+                    g.DrawEllipse(ring, x + 16 * scale, y + 20 * scale, 20 * scale, 20 * scale);
+                    if (progress > 0) g.DrawArc(accent, x + 16 * scale, y + 20 * scale, 20 * scale, 20 * scale, -90, 360 * progress);
+                    g.DrawString("即将开始操作，请暂停键鼠", title, white, x + 48 * scale, y + 9 * scale);
+                    g.DrawString("Ctrl+Esc 暂停", detail, soft, x + 48 * scale, y + 34 * scale);
+                    string remaining = (Math.Max(0, PreparationMs - elapsed) / 1000.0).ToString("0.0") + " 秒后开始";
+                    SizeF size = g.MeasureString(remaining, detail);
+                    g.DrawString(remaining, detail, soft, x + bw - 16 * scale - size.Width, y + 34 * scale);
+                    g.FillRectangle(track, x + 48 * scale, y + 56 * scale, bw - 64 * scale, 2 * scale);
+                    if (progress > 0) g.FillRectangle(bar, x + 48 * scale, y + 56 * scale, (bw - 64 * scale) * progress, 2 * scale);
+                }
+            });
         }
 
-        static void PaintBadge(System.Drawing.Graphics g, string txt, int opacity, bool red)
+        static void PaintStatusChip(System.Drawing.Graphics g, int w, int h, string text, Color tint)
         {
-            // The human asked for a QUIETER badge (2026-09-13): they already know what the overlay
-            // means, so it must inform without shouting. Font at 75% (15 -> 11.25 pt), and text,
-            // outline and background all pulled well below full opacity.
-            int o = Math.Max(40, Math.Min(255, opacity));
-            using (System.Drawing.Font f = new System.Drawing.Font("Microsoft YaHei", 11.25f, System.Drawing.FontStyle.Bold))
+            Rectangle display = OverlayDisplay(w, h);
+            float scale = Math.Max(1f, Math.Min(1.25f, display.Width / 1920f));
+            using (var font = new Font("Microsoft YaHei UI", 9f * scale))
             {
-                System.Drawing.SizeF sz = g.MeasureString(txt, f);
-                float bw = sz.Width + 24f, bh = sz.Height + 12f;
-                float x = 22f, y = 22f;
-                System.Drawing.Drawing2D.GraphicsPath p = new System.Drawing.Drawing2D.GraphicsPath();
-                AddRound(p, x, y, bw, bh, 10f);
-                System.Drawing.Color edge = red
-                    ? System.Drawing.Color.FromArgb((int)(o * 0.42), 255, 150, 150)
-                    : System.Drawing.Color.FromArgb((int)(o * 0.34), 150, 200, 255);
-                using (System.Drawing.SolidBrush b = new System.Drawing.SolidBrush(
-                           red ? System.Drawing.Color.FromArgb((int)(o * 0.30), 46, 8, 12)
-                               : System.Drawing.Color.FromArgb((int)(o * 0.26), 10, 14, 22)))
-                    g.FillPath(b, p);
-                using (System.Drawing.Pen pen = new System.Drawing.Pen(edge, 1.4f))
-                    g.DrawPath(pen, p);
-                p.Dispose();
-                using (System.Drawing.SolidBrush tb = new System.Drawing.SolidBrush(
-                           red ? System.Drawing.Color.FromArgb((int)(o * 0.70), 255, 226, 226)
-                               : System.Drawing.Color.FromArgb((int)(o * 0.62), 236, 245, 255)))
-                    g.DrawString(txt, f, tb, x + 12f, y + 6f);
+                SizeF measured = g.MeasureString(text, font);
+                float bw = Math.Min(measured.Width + 38 * scale, display.Width - 24), bh = 28 * scale;
+                float x = display.Left + (display.Width - bw) / 2, y = display.Top + 8 * scale;
+                using (var shape = new System.Drawing.Drawing2D.GraphicsPath())
+                using (var fill = new SolidBrush(Color.FromArgb(222, 22, 26, 36)))
+                using (var outline = new Pen(Color.FromArgb(90, tint), 1f))
+                using (var accent = new SolidBrush(Color.FromArgb(255, tint)))
+                using (var ink = new SolidBrush(Color.FromArgb(250, 235, 239, 248)))
+                {
+                    AddRound(shape, x, y, bw, bh, 12 * scale); g.FillPath(fill, shape); g.DrawPath(outline, shape);
+                    g.FillEllipse(accent, x + 12 * scale, y + 11 * scale, 6 * scale, 6 * scale);
+                    g.DrawString(text, font, ink, x + 24 * scale, y + (bh - measured.Height) / 2);
+                }
             }
         }
 
-        /// The stopped state: a RED border plus a red badge, steady (no breathing) — the
-        /// computer-use session is dead until a human re-arms it.
         static void PaintStop(IntPtr bits, int w, int h)
         {
-            WithGraphics(bits, w, h, delegate (System.Drawing.Graphics g)
-            {
-                int band = Math.Max(22, Math.Min(37, Math.Min(w, h) / 32));   // 80% of what it was (cap included)
-                int r = band + 10;
-                const int N = 60;
-                float step = (float)band / N;
-                for (int i = 0; i < N; i++)
-                {
-                    double t = (double)i / N;
-                    int a = (int)Math.Round(248 * Math.Pow(1 - t, 2.0));
-                    if (a <= 0) continue;
-                    float inset = i * step;
-                    using (System.Drawing.Pen pen = new System.Drawing.Pen(
-                               System.Drawing.Color.FromArgb(a, 238, 66, 74), step + 1.2f))
-                    {
-                        System.Drawing.Drawing2D.GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath();
-                        AddRound(path, inset, inset, w - inset * 2, h - inset * 2, Math.Max(1, r - inset));
-                        g.DrawPath(pen, path);
-                        path.Dispose();
-                    }
-                }
-                PaintBadge(g, "已暂停 · Ctrl+Alt+R 继续 · Ctrl+Alt+Q 退出", 252, true);
+            WithGraphics(bits, w, h, delegate(System.Drawing.Graphics g) {
+                Color tint = Color.FromArgb(240, 84, 102);
+                PaintEdgeRail(g, new Rectangle(0, 0, w, h), tint);
+                PaintStatusChip(g, w, h, "操作已暂停 · Ctrl+Alt+R 继续", tint);
             });
         }
 
-        /// Yellow "a screenshot was just taken" rectangle around the captured region —
-        /// same stepped-gradient treatment, no strokes, no hard edges.
         static void PaintFlash(IntPtr bits, int w, int h)
         {
             int fx = _fx, fy = _fy, fw = _fw, fh = _fh;
@@ -1019,32 +1252,8 @@ namespace DshComputerUse.Worker
             if (fx + fw > w) fw = w - fx;
             if (fy + fh > h) fh = h - fy;
             if (fw < 8 || fh < 8) { fx = 0; fy = 0; fw = w; fh = h; }
-
-            WithGraphics(bits, w, h, delegate (System.Drawing.Graphics g)
-            {
-                // 2026-09-12 (human): the capture cue on its own, 40% narrower again — 32 -> 19.
-                // The corner radius scales with it (13 -> 8) so the strip still reads as a thin
-                // glow instead of a fat rounded rectangle. Width only: the alpha profile is
-                // untouched, so the cue keeps its brightness.
-                int band = 19;
-                int r = 8;
-                const int N = 40;
-                float step = (float)band / N;
-                for (int i = 0; i < N; i++)
-                {
-                    double t = (double)i / N;
-                    int a = (int)Math.Round(200 * Math.Pow(1 - t, 1.9));
-                    if (a <= 0) continue;
-                    float inset = i * step;
-                    using (System.Drawing.Pen pen = new System.Drawing.Pen(
-                               System.Drawing.Color.FromArgb(a, 255, 186, 20), step + 1.2f))
-                    {
-                        System.Drawing.Drawing2D.GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath();
-                        AddRound(path, fx + inset, fy + inset, fw - inset * 2, fh - inset * 2, Math.Max(1, r - inset));
-                        g.DrawPath(pen, path);
-                        path.Dispose();
-                    }
-                }
+            WithGraphics(bits, w, h, delegate(System.Drawing.Graphics g) {
+                PaintEdgeRail(g, new Rectangle(fx, fy, fw, fh), Color.FromArgb(247, 193, 62));
             });
         }
 
@@ -1056,6 +1265,7 @@ namespace DshComputerUse.Worker
                 using (System.Drawing.Graphics g = System.Drawing.Graphics.FromImage(bmp))
                 {
                     g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
+                    g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit;
                     g.Clear(System.Drawing.Color.Transparent);
                     draw(g);
                 }
@@ -1232,10 +1442,12 @@ namespace DshComputerUse.Worker
             // separate statements, so a Q between the check and the write re-lit a dead cycle.
             lock (SyncLock)
             {
+                Program.InvalidateActiveInput();
                 _temporary = null;
                 _engaged = false;
                 _stopped = false;
                 CycleLit = false;             // R2: the cycle is dead and must not be revived by anyone
+                _controlsReleased = true;
                 Disarm();                     // ... and its monitors die WITH it, not at the next turn
                 try { Glow.Kill(); } catch { }
                 try { Glow.Ask(false); } catch { }
@@ -1258,6 +1470,7 @@ namespace DshComputerUse.Worker
             {
                 if (_exited) return false;
                 if (!CycleLit) Program.ResetKickoffFocus();
+                _controlsReleased = false;
                 CycleLit = true;      // an agent cycle is live: cyan is on (R1)
                 Arm();                // "Computer use 一旦启用，立即挂打断监听"
                 // A BRAKE OUTRANKS "THINKING" (cold-start bug, 2026-09-13): if a stop is already
@@ -1281,6 +1494,19 @@ namespace DshComputerUse.Worker
                 return true;
             }
         }
+        public static bool TryEndCycle()
+        {
+            SyncExitedFromFile(); SyncFromFile();
+            lock (SyncLock)
+            {
+                if (_engaged || _stopped || PauseRequested || ExitRequested) return false;
+                _controlsReleased = true;
+                CycleLit = false;
+                Disarm(); Glow.Kill();
+                Program.ReleaseOwnedInputs(); Program.ReleaseDesktopOwnership();
+                return true;
+            }
+        }
 
         /// Was the record written after this process started? Only then is it news rather than an
         /// inherited fact. (The record carries its own `at=` line precisely so this is answerable
@@ -1355,7 +1581,7 @@ namespace DshComputerUse.Worker
             }
             // OUTSIDE the lock: Notify writes to stdout, and a full pipe must never hold the lock the
             // exit and the cycle-opener share.
-            if (adopted) ReleaseStuck();   // adopted exit == detected exit, cleanup included
+            if (adopted) { ReleaseStuck(); Program.ReleaseDesktopOwnership(); }
             if (announce) Notify("exit", ExitSummary());
         }
 
@@ -1451,6 +1677,9 @@ namespace DshComputerUse.Worker
         static IntPtr _hook = IntPtr.Zero;
         static Native.LowLevelKeyboardProc _proc;      // keep alive: the GC must not collect it
         static IntPtr _mouseHook = IntPtr.Zero;
+        static readonly uint CurrentPid = (uint)Process.GetCurrentProcess().Id;
+        static readonly ManualResetEvent _hooksInitialized = new ManualResetEvent(false);
+        static volatile bool _hooksReady;
         static Native.LowLevelMouseProc _mouseProc;    // same: the GC must not collect it
         static Thread _thread;
 
@@ -1720,9 +1949,14 @@ namespace DshComputerUse.Worker
                 _proc = HookCallback;
                 IntPtr hmod = Native.GetModuleHandle(null);
                 _hook = Native.SetWindowsHookEx(Native.WH_KEYBOARD_LL, _proc, hmod, 0);
+                int keyboardError = _hook == IntPtr.Zero ? Marshal.GetLastWin32Error() : 0;
                 // Same thread, same message loop: a second low-level hook for the wheel.
                 _mouseProc = MouseHookCallback;
                 _mouseHook = Native.SetWindowsHookEx(Native.WH_MOUSE_LL, _mouseProc, hmod, 0);
+                int mouseError = _mouseHook == IntPtr.Zero ? Marshal.GetLastWin32Error() : 0;
+                _hooksReady = _hook != IntPtr.Zero && _mouseHook != IntPtr.Zero;
+                _hooksInitialized.Set();
+                if (!_hooksReady) Program.AuditRecord("CONTROL-HOOK-ERROR", "keyboard=" + keyboardError + "; mouse=" + mouseError);
                 Native.NativeMsg msg;
                 while (Native.GetMessage(out msg, IntPtr.Zero, 0, 0) > 0)
                 {
@@ -1730,13 +1964,33 @@ namespace DshComputerUse.Worker
                     Native.DispatchMessage(ref msg);
                 }
             }
-            catch { /* the brake must never take the worker down */ }
+            catch (Exception ex) { Program.AuditRecord("CONTROL-HOOK-ERROR", ex.GetType().Name); }
+            finally { _hooksReady = false; _hooksInitialized.Set(); }
+        }
+
+        public static void RequireControlHooks()
+        {
+            if (!_hooksInitialized.WaitOne(1500) || !_hooksReady)
+            {
+                var error = new Exception("CONTROL_HOOK_UNAVAILABLE: physical input monitoring did not start or has stopped; no input was dispatched.");
+                error.Data["code"] = "CONTROL_HOOK_UNAVAILABLE";
+                error.Data["outcome"] = "not-dispatched";
+                throw error;
+            }
         }
 
         // Hook callbacks only record ownership and enqueue control work. Serial execution
         // preserves Ctrl+Esc / resume / exit ordering without blocking the OS hook on I/O.
-        static int _pendingPauses;
+        static int _pendingPauses, _pendingExits;
         public static bool PauseRequested { get { return Volatile.Read(ref _pendingPauses) > 0; } }
+        public static bool ExitRequested { get { return Volatile.Read(ref _pendingExits) > 0; } }
+        public static bool FinishOneShotControls()
+        {
+            if (!PauseRequested && !ExitRequested) return true;
+            // A one-shot process must give the recognised chord a chance to persist
+            // STOP/EXITED before Main returns and its background threads disappear.
+            return SpinWait.SpinUntil(delegate { return !PauseRequested && !ExitRequested; }, 5000);
+        }
         static readonly ConcurrentQueue<Action> ControlQueue = new ConcurrentQueue<Action>();
         static int _controlWorkQueued;
         internal static void QueueControl(Action action)
@@ -1751,6 +2005,31 @@ namespace DshComputerUse.Worker
                 } while (!ControlQueue.IsEmpty && Interlocked.CompareExchange(ref _controlWorkQueued, 1, 0) == 0);
             });
         }
+        static void QueueDesktopControl(Action action, Action finished = null)
+        {
+            QueueControl(delegate {
+                // Serialize with graceful release: a queued physical hotkey may not
+                // reopen a completed cycle or steer an exit into its continuing chat.
+                try
+                {
+                    lock (SyncLock)
+                    {
+                        if (!ControlListenersEnabled || !Program.TryClaimDesktop("physical control"))
+                        { Program.AuditRecord("CONTROL-SKIPPED", ControlListenersEnabled ? "desktop owned by another worker" : "cycle released"); return; }
+                        try { action(); }
+                        finally { if (!CycleLit) Program.ReleaseDesktopOwnership(); }
+                    }
+                }
+                catch (Exception ex) { Program.AuditRecord("CONTROL-ERROR", ex.GetType().Name); }
+                finally { if (finished != null) finished(); }
+            });
+        }
+
+        static void QueueExit(Action exit)
+        {
+            Interlocked.Increment(ref _pendingExits);
+            QueueDesktopControl(exit, delegate { Interlocked.Decrement(ref _pendingExits); });
+        }
         public static string ControlHotkey(uint vk, bool down, bool human, bool ctrl, bool alt, bool shift, bool win, bool live)
         {
             if (!down || !human) return "";
@@ -1760,8 +2039,7 @@ namespace DshComputerUse.Worker
             return "";
         }
         static bool _suppressPauseEsc;
-        static bool _havePhysicalPoint;
-        static POINT _physicalPoint;
+        static readonly PointerHandoffTolerance PointerMotion = new PointerHandoffTolerance();
         public static bool PhysicalEvent(IntPtr extra, uint flags, uint injectedMask)
         { return extra != OwnMagic && (flags & injectedMask) == 0; }
 
@@ -1773,15 +2051,18 @@ namespace DshComputerUse.Worker
                 {
                     var m = (Native.MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(Native.MSLLHOOKSTRUCT));
                     if (m.dwExtraInfo != OwnMagic) Interlocked.Increment(ref _externalInput);
-                    if (PhysicalEvent(m.dwExtraInfo, m.flags, 3))
+                    bool physical = PhysicalEvent(m.dwExtraInfo, m.flags, 3);
+                    int message = wParam.ToInt32();
+                    // Significant idle motion invalidates observations, but does not yield.
+                    bool movement = message == 0x200 && PointerMotion.Record(m.pt.X, m.pt.Y, physical,
+                        true, Handoff.Active, HumanClock.ElapsedMilliseconds);
+                    if (physical)
                     {
-                        int message = wParam.ToInt32(), key = 0;
-                        bool down = false, up = false, activity = true;
+                        int key = 0;
+                        bool down = false, up = false, activity = true, deliberate = false;
                         switch (message)
                         {
-                            case 0x200:
-                                activity = !_havePhysicalPoint || m.pt.X != _physicalPoint.X || m.pt.Y != _physicalPoint.Y;
-                                _physicalPoint = m.pt; _havePhysicalPoint = true; break;
+                            case 0x200: activity = movement; deliberate = movement; break;
                             case 0x201: key = 1; down = true; break;
                             case 0x202: key = 1; up = true; break;
                             case 0x204: key = 2; down = true; break;
@@ -1793,7 +2074,7 @@ namespace DshComputerUse.Worker
                             case 0x20A: case 0x20E: activity = unchecked((short)(m.mouseData >> 16)) != 0; break;
                             default: activity = false; break;
                         }
-                        if (activity) RecordHumanInput(key, down, up);
+                        if (activity) RecordHumanInput(key, down, up, deliberate);
                     }
                 }
             }
@@ -1820,28 +2101,26 @@ namespace DshComputerUse.Worker
                         { if (up) _suppressPauseEsc = false; return new IntPtr(1); }
                         bool ctrl = _humanCtrl && (Native.GetAsyncKeyState(Native.VK_CONTROL) & 0x8000) != 0;
                         bool alt = _humanAlt && (Native.GetAsyncKeyState(Native.VK_MENU) & 0x8000) != 0;
-                        string hotkey = ControlHotkey(k.vkCode, down, human, ctrl, alt,
-                            Handoff.Held(0x10), Handoff.Held(0x5B) || Handoff.Held(0x5C), CycleLit && !_exited);
+                        string hotkey = ControlListenersEnabled ? ControlHotkey(k.vkCode, down, human, ctrl, alt,
+                            Handoff.Held(0x10), Handoff.Held(0x5B) || Handoff.Held(0x5C), CycleLit && !_exited) : "";
                         if (hotkey == "pause")
                         {
                             _suppressPauseEsc = true;
-                            Interlocked.Increment(ref _pendingPauses);
                             // The hook marks ownership immediately; do not perform SendInput or
                             // filesystem work on this OS hook thread.
-                            string evidence = ChordEvidence(k, ctrl, alt);
-                            QueueControl(delegate {
-                                try { Engage("Ctrl+Esc chord detected", false, "hook", evidence); }
-                                finally { Interlocked.Decrement(ref _pendingPauses); }
-                            });
+                            var evidence = ChordEvidence(k, ctrl, alt);
+                            Interlocked.Increment(ref _pendingPauses);
+                            QueueDesktopControl(delegate { Engage("Ctrl+Esc chord detected", false, "hook", evidence()); },
+                                delegate { Interlocked.Decrement(ref _pendingPauses); });
                             return new IntPtr(1); // Ctrl+Esc must not also open the Windows Start menu.
                         }
                         if (hotkey == "exit")
                         {
-                            string evidence = ChordEvidence(k, ctrl, alt);
-                            QueueControl(delegate { Exit("Ctrl+Alt+Q chord detected", "hook", evidence); });
+                            var evidence = ChordEvidence(k, ctrl, alt);
+                            QueueExit(delegate { Exit("Ctrl+Alt+Q chord detected", "hook", evidence()); });
                         }
                         else if (hotkey == "resume")
-                            QueueControl(delegate { Clear(); });
+                            QueueDesktopControl(delegate { Clear(); });
                     }
                 }
             }
@@ -1886,6 +2165,7 @@ namespace DshComputerUse.Worker
             // SendInputChecked (which now refuses after an exit): releasing what is stuck is exactly
             // the cleanup that must still be allowed.
             ReleaseStuck();
+            Program.ReleaseDesktopOwnership();
             Program.AuditRecord("EXIT", _exitSource + "\t" + why + "\t" + _exitEvidence);
             Notify("exit", ExitSummary());
         }
@@ -1893,7 +2173,7 @@ namespace DshComputerUse.Worker
         /// The chord as it was SEEN: the fields someone can re-check, including whose Ctrl/Alt the
         /// hook recorded and which window was in front. Deliberately verbose — this line is the
         /// difference between "the human pressed it" and "we cannot know who pressed it".
-        static string ChordEvidence(Native.KBDLLHOOKSTRUCT k, bool ctrl, bool alt)
+        static Func<string> ChordEvidence(Native.KBDLLHOOKSTRUCT k, bool ctrl, bool alt)
         {
             StringBuilder sb = new StringBuilder();
             sb.Append("vk=0x").Append(k.vkCode.ToString("X2"));
@@ -1907,31 +2187,37 @@ namespace DshComputerUse.Worker
             // later whether "the human pressed it" was ever measurable — and note that OURSELVES
             // (extra=OUR_MAGIC) is a different, stronger answer than "some injector".
             sb.Append(" injected=").Append((k.flags & Native.LLKHF_INJECTED) != 0 ? "1" : "0");
-            try
+            IntPtr fg = Native.GetForegroundWindow();
+            uint fgPid;
+            Native.GetWindowThreadProcessId(fg, out fgPid);
+            sb.Append(" fgPid=").Append(fgPid);
+            // Capture the foreground identity on the hook thread. Enrich it on the
+            // control queue without sending a message to our own overlay window.
+            return delegate
             {
-                IntPtr fg = Native.GetForegroundWindow();
-                uint fgPid;
-                Native.GetWindowThreadProcessId(fg, out fgPid);
-                sb.Append(" fgPid=").Append(fgPid);
-                try { sb.Append(" fg=").Append(Process.GetProcessById((int)fgPid).ProcessName); } catch { }
-                StringBuilder t = new StringBuilder(256);
-                if (Native.GetWindowText(fg, t, 256) > 0)
+                try
                 {
-                    string title = t.ToString();
-                    if (title.Length > 60) title = title.Substring(0, 60);
-                    sb.Append(" fgTitle=\"").Append(title.Replace("\t", " ")).Append('"');
+                    using (var proc = Process.GetProcessById((int)fgPid)) sb.Append(" fg=").Append(proc.ProcessName);
+                    uint currentPid;
+                    Native.GetWindowThreadProcessId(fg, out currentPid);
+                    StringBuilder t = new StringBuilder(256);
+                    if (currentPid == fgPid && fgPid != CurrentPid && Native.GetWindowText(fg, t, 256) > 0)
+                    {
+                        string title = t.ToString();
+                        if (title.Length > 60) title = title.Substring(0, 60);
+                        sb.Append(" fgTitle=\"").Append(title.Replace("\t", " ")).Append('"');
+                    }
                 }
-            }
-            catch { }
-            return sb.ToString();
+                catch { }
+                return sb.ToString();
+            };
         }
 
         /// Polling fallback for the human's combos.
         ///
         /// The low-level hook is the primary path, but it only reports what Windows hands it: a
-        /// missed keydown would leave the machine stopped with no discoverable way back. This thread
-        /// independently watches the key STATE — the "pressed since the last call" bit cannot be
-        /// missed when polled every 40 ms — so Q always exits and R always releases, hook or no hook.
+        /// missed keydown would otherwise have no fallback. Poll the press bits as an additional
+        /// witness for Q/R while the hook has confirmed human-held modifiers.
         static void PollThread()
         {
             bool prevQ = false, prevR = false;
@@ -1963,21 +2249,19 @@ namespace DshComputerUse.Worker
                     bool r = (Native.GetAsyncKeyState(Native.VK_R) & 1) != 0;
                     bool agentQuiet = _agentActAt == 0 || unchecked(Environment.TickCount - _agentActAt) > 400;
                     if (warm < 3) warm++;
-                    else if (_humanCtrl && _humanAlt && asyncCtrl && asyncAlt && agentQuiet)
+                    else if (ControlListenersEnabled && _humanCtrl && _humanAlt && asyncCtrl && asyncAlt && agentQuiet)
                     {
                         // R FIRST: Ctrl+Alt+R is the human's explicit re-arm, and a stale Q bit must
                         // never beat it — pressing the key that brings computer use BACK used to be
                         // able to END it instead.
-                        if (r && !prevR) QueueControl(delegate { Clear(); });
+                        if (r && !prevR) QueueDesktopControl(delegate { Clear(); });
                         else if (q && !prevQ)
                         {
                             Native.KBDLLHOOKSTRUCT kk = new Native.KBDLLHOOKSTRUCT();
                             kk.vkCode = Native.VK_Q;
-                            string evidence =
-                                 "q-latch + hook-tracked modifiers + measured async key state " +
-                                 "(no keydown was seen by the hook); " +
-                                 ChordEvidence(kk, asyncCtrl, asyncAlt);
-                            QueueControl(delegate { Exit("Ctrl+Alt+Q chord detected", "poll", evidence); });
+                            var evidence = ChordEvidence(kk, asyncCtrl, asyncAlt);
+                            QueueExit(delegate { Exit("Ctrl+Alt+Q chord detected", "poll",
+                                "q-latch + hook-tracked modifiers + measured async key state; " + evidence()); });
                         }
                     }
                     prevQ = q; prevR = r;
@@ -1993,6 +2277,8 @@ namespace DshComputerUse.Worker
         // durable manual brake and never creates a STOP record.
         static int _agentActAt;
         static volatile bool _armed = false;
+        static volatile bool _controlsReleased = true;
+        public static bool ControlListenersEnabled { get { return !_controlsReleased; } }
         public static volatile bool CycleLit;
         public static bool Armed { get { return _armed; } }
         public static bool Exited { get { return _exited; } }
@@ -2000,27 +2286,77 @@ namespace DshComputerUse.Worker
         static readonly HumanInputState Handoff = new HumanInputState();
         static readonly object HandoffPublishLock = new object();
         static string _publishedHandoff = "idle";
+        static long _physicalInputEpoch, _publishedInputEpoch;
         static int _handoffWorkQueued;
         public static bool HumanActive { get { return Handoff.Active; } }
         public static long HumanRevision { get { return Handoff.Revision; } }
         public static bool HumanHolds(int vk) { return Handoff.Held(vk); }
-        public static object CooperationState() { return Handoff.Snapshot(HumanClock.ElapsedMilliseconds); }
+        public static long InputEpoch { get { return Interlocked.Read(ref _physicalInputEpoch); } }
+        public static object CooperationState()
+        {
+            var state = (Dictionary<string, object>)Handoff.Snapshot(HumanClock.ElapsedMilliseconds);
+            state["inputEpoch"] = InputEpoch; state["mouseTolerancePx"] = PointerHandoffTolerance.DistancePx;
+            return state;
+        }
         static void ResetMonitorRun() { /* Manual recovery must not erase physical input history. */ }
+        // ---------- secure-desktop (UAC / lock screen) dispatch gate, human request 2026-11-04 ----------
+        static readonly SecureDesktopWatch SecureWatch = new SecureDesktopWatch();
+        public static bool SecureDesktopActive { get { return SecureWatch.Active; } }
+        static bool InputDesktopReachable()
+        {
+            IntPtr desktop = Native.OpenInputDesktop(0, false, 0x0001);   // DESKTOP_READOBJECT
+            if (desktop != IntPtr.Zero) { Native.CloseDesktop(desktop); return true; }
+            return false;
+        }
+        /// Polled from the monitor thread. Audits and notifies TRANSITIONS only.
+        static void PollSecureDesktop()
+        {
+            if (!SecureWatch.Observe(InputDesktopReachable())) return;
+            bool active = SecureWatch.Active;
+            Program.AuditRecord(active ? "SECURE-DESKTOP-ENGAGED" : "SECURE-DESKTOP-CLEARED",
+                active
+                    ? "input desktop unreachable (UAC prompt or lock screen); input dispatch paused until it returns"
+                    : "input desktop reachable again; dispatch may continue");
+            Notify("secure", active ? "active" : "cleared");
+        }
+        /// Input ops refuse to dispatch while the secure desktop stands: no injection can reach
+        /// it anyway, and a clean refusal plus a notified human beats a blind timeout mid-cycle.
+        public static void RequireNormalDesktop()
+        {
+            if (!SecureWatch.Active) return;
+            var error = new Exception("SECURE_DESKTOP_ACTIVE: the Windows secure desktop (a UAC prompt or the lock screen) is up; no input was dispatched. Ask the human to answer the prompt; dispatch resumes automatically once the normal desktop returns.");
+            error.Data["code"] = "SECURE_DESKTOP_ACTIVE";
+            error.Data["outcome"] = "not-dispatched";
+            throw error;
+        }
         public static void Arm() { _armed = true; Handoff.Enable(CycleLit && !_exited, HumanClock.ElapsedMilliseconds); }
         public static void Disarm() { _armed = false; Handoff.Enable(false, HumanClock.ElapsedMilliseconds); PublishHandoff(); }
         public static void AgentActed() { _agentActAt = Environment.TickCount; }
+        public static void BeginActuation()
+        {
+            POINT point; if (Native.GetCursorPos(out point)) PointerMotion.Reset(point.X, point.Y);
+            Glow.ActuationBegin();
+            Handoff.SetActing(true, HumanClock.ElapsedMilliseconds);
+        }
+        public static void EndActuation()
+        {
+            Handoff.SetActing(false, HumanClock.ElapsedMilliseconds);
+            Glow.ActuationEnd();
+        }
         static bool IsBareModifier(uint vk)
         {
             return vk == Native.VK_SHIFT || vk == Native.VK_CONTROL || vk == Native.VK_MENU ||
                    vk == 0xA0 || vk == 0xA1 || vk == 0xA2 || vk == 0xA3 ||
                    vk == 0xA4 || vk == 0xA5 || vk == 0x5B || vk == 0x5C;
         }
-        public static void RecordHumanInput(int key, bool down, bool up)
+        public static void RecordHumanInput(int key, bool down, bool up) { RecordHumanInput(key, down, up, false); }
+        public static void RecordHumanInput(int key, bool down, bool up, bool deliberate)
         {
+            Interlocked.Increment(ref _physicalInputEpoch);
             long now = HumanClock.ElapsedMilliseconds;
             bool was = Handoff.Active;
             Handoff.Enable(_armed && CycleLit && !_exited, now);
-            Handoff.Record(key, down, up, now);
+            Handoff.Record(key, down, up, now, deliberate);
             if (!was && Handoff.Active && Interlocked.CompareExchange(ref _handoffWorkQueued, 1, 0) == 0)
                 ThreadPool.QueueUserWorkItem(delegate {
                     try { Program.ReleaseOwnedInputs(); PublishHandoff(); }
@@ -2032,16 +2368,22 @@ namespace DshComputerUse.Worker
             lock (HandoffPublishLock)
             {
                 string phase = Handoff.Phase;
-                if (phase == _publishedHandoff) return;
+                long epoch = InputEpoch;
+                if (phase == _publishedHandoff && epoch == _publishedInputEpoch) return;
+                bool changed = phase != _publishedHandoff;
                 _publishedHandoff = phase;
+                _publishedInputEpoch = epoch;
+                if (!ControlListenersEnabled && !CycleLit && phase == "idle") return;
                 if (phase != "idle") Glow.HumanYield();
-                Program.AuditRecord("HUMAN-HANDOFF", "phase=" + phase + "; revision=" + HumanRevision + "; kind=" + Handoff.LastKind);
+                if (changed) Program.AuditRecord("HUMAN-HANDOFF", "phase=" + phase + "; revision=" + HumanRevision + "; kind=" + Handoff.LastKind);
                 Notify("handoff", phase);
             }
         }
         static void MonitorHuman()
         {
+            if (!ControlListenersEnabled) return;
             SyncExitedFromFile();
+            PollSecureDesktop();
             long now = HumanClock.ElapsedMilliseconds;
             Handoff.Enable(_armed && CycleLit && !_exited, now);
             Handoff.Tick(now);
@@ -2371,7 +2713,7 @@ namespace DshComputerUse.Worker
         static readonly HashSet<string> ReadOnlyOps = new HashSet<string> {
             "selftest", "cursor", "panic", "resume", "recover", "echoargs", "ping", "screens",
             "windows", "uia", "uiaFromPoint", "uiaFocused", "waitForIdle", "clipRead",
-            "capture", "annotate", "waitStable", "waitChange", "focus", "frameSig", "probe",
+            "capture", "ocr", "annotate", "waitStable", "waitChange", "focus", "frameSig", "probe",
             // diagnostics that must be able to ANSWER while a brake is up: they send no input and
             // light nothing, which is exactly when someone needs to inspect the release decision
             "keyClass", "stuckPlan",
@@ -2459,6 +2801,7 @@ namespace DshComputerUse.Worker
                 try { Glow.Stopped(false); } catch { }
                 // Re-arming re-baselines the human monitor: the travel that tripped the brake must not
                 // still be sitting in the accumulator, or the very next poll would brake again.
+                if (CycleLit && !_exited) Glow.Thinking(0);
                 _agentActAt = 0;
             }
             if (was) Notify("resume", "");
@@ -2648,12 +2991,16 @@ namespace DshComputerUse.Worker
         bool finished;
         ClipboardLease(IClipboardAccess access, List<ClipboardBytes> previous, uint written)
         { this.access = access; this.previous = previous; this.written = written; }
+        /// Returns null when the previous clipboard cannot be preserved (private formats, odd
+        /// sizes). The caller then downgrades to a plain overwrite-paste with a warning rather
+        /// than refusing — see Snapshot's incident note (2026-11-04).
         public static ClipboardLease Begin(IClipboardAccess access, string text)
         {
             using (var session = access.Open())
             {
                 if (session.Sequence == 0) throw new Exception("Clipboard sequence unavailable; clipboard was not changed.");
-                var previous = session.Snapshot(); // refuse unsupported formats BEFORE clearing anything
+                var previous = session.Snapshot(); // null = cannot preserve: caller downgrades, we do not clear anything here
+                if (previous == null) return null;
                 try
                 {
                     session.Replace(new List<ClipboardBytes> {
@@ -2692,8 +3039,9 @@ namespace DshComputerUse.Worker
         }
     }
 
-    // Copy only explicitly supported HGLOBAL formats. Unknown/private or GDI formats are refused
-    // without mutation; callers can use Unicode input instead of losing an opaque clipboard item.
+    // Copy only explicitly supported HGLOBAL formats. Unknown/private or GDI formats cannot be
+    // snapshotted — Snapshot returns null for them and the caller downgrades to
+    // paste-without-restore with a warning (incident 2026-11-04) instead of losing the paste.
     public sealed class NativeClipboardAccess : IClipboardAccess, IDisposable
     {
         readonly NativeWindow window = new NativeWindow();
@@ -2717,14 +3065,6 @@ namespace DshComputerUse.Worker
         [DllImport("kernel32.dll")] static extern UIntPtr GlobalSize(IntPtr memory);
         [DllImport("kernel32.dll")] static extern IntPtr GlobalFree(IntPtr memory);
         [DllImport("kernel32.dll")] static extern void SetLastError(uint error);
-        static Exception Unavailable(string reason)
-        {
-            var error = new Exception("CLIPBOARD_PRESERVATION_UNAVAILABLE: " + reason +
-                "; clipboard unchanged. Use mode:unicode if suitable for the target editor.");
-            error.Data["code"] = "CLIPBOARD_PRESERVATION_UNAVAILABLE";
-            error.Data["outcome"] = "not-dispatched";
-            return error;
-        }
         public static bool Supported(uint format, string name)
         {
             if (format == 1 || format == 7 || format == 8 || format == 13 || format == 15 || format == 16 || format == 17) return true;
@@ -2746,6 +3086,13 @@ namespace DshComputerUse.Worker
             }
             public uint Sequence { get { return GetClipboardSequenceNumber(); } }
             public void Dispose() { if (opened) { CloseClipboard(); opened = false; } }
+            /// Returns null when the current clipboard cannot be fully snapshotted (private or GDI
+            /// formats, too many/oversized entries, lock failures). NULL MEANS "cannot preserve",
+            /// not "refuse to work" (human incident 2026-11-04): a WeChat-session clipboard carried
+            /// private format 49161, paste was refused, the JS auto-fallback re-typed 37 CJK chars
+            /// as unicode keystrokes and a garbled message actually went out. Losing an opaque
+            /// clipboard item is a recoverable local cost; a mis-typed external message is not —
+            /// so the caller downgrades to paste-without-restore instead of refusing.
             public List<ClipboardBytes> Snapshot()
             {
                 var formats = new List<uint>();
@@ -2756,27 +3103,26 @@ namespace DshComputerUse.Worker
                     format = EnumClipboardFormats(format);
                     if (format == 0)
                     {
-                        if (Marshal.GetLastWin32Error() != 0) throw Unavailable("format enumeration failed");
+                        if (Marshal.GetLastWin32Error() != 0) return null;
                         break;
                     }
                     var name = new StringBuilder(256);
                     if (format >= 0xC000) GetClipboardFormatName(format, name, name.Capacity);
-                    if (!Supported(format, name.ToString())) throw Unavailable("unsupported format " + format);
+                    if (!Supported(format, name.ToString())) return null;
                     formats.Add(format);
-                    if (formats.Count > 64) throw Unavailable("too many formats");
+                    if (formats.Count > 64) return null;
                 }
                 var result = new List<ClipboardBytes>();
                 long total = 0;
                 foreach (uint id in formats)
                 {
                     IntPtr handle = GetClipboardData(id);
-                    if (handle == IntPtr.Zero) throw Unavailable("data unavailable for format " + id);
+                    if (handle == IntPtr.Zero) return null;
                     ulong size = GlobalSize(handle).ToUInt64();
-                    if (size == 0 || size > 32 * 1024 * 1024 || total + (long)size > 32 * 1024 * 1024)
-                        throw Unavailable("clipboard snapshot exceeds supported size");
+                    if (size == 0 || size > 32 * 1024 * 1024 || total + (long)size > 32 * 1024 * 1024) return null;
                     total += (long)size;
                     IntPtr data = GlobalLock(handle);
-                    if (data == IntPtr.Zero) throw Unavailable("clipboard data could not be locked");
+                    if (data == IntPtr.Zero) return null;
                     try
                     {
                         var bytes = new byte[(int)size]; Marshal.Copy(data, bytes, 0, bytes.Length);
@@ -2822,13 +3168,13 @@ namespace DshComputerUse.Worker
         static readonly object OutLock = new object();   // responses AND unsolicited events share stdout
         static readonly DateTime Epoch = new DateTime(1970, 1, 1);
 
-        // Position correction is diagnostic only. Physical input immediately yields;
-        // no distance, reversal, wheel-count or screen-corner rule latches a pause.
+        // Position correction is diagnostic only. Deliberate physical takeover during
+        // actual input yields; incidental mouse jitter and idle use do not pause the task.
         static int _positionCorrections;
         static string _dpiNote = "unset";
         static readonly HashSet<string> ObsOps = new HashSet<string>
         {
-            "ping", "echoargs", "screens", "cursor", "capture", "annotate",
+            "ping", "echoargs", "screens", "cursor", "capture", "ocr", "annotate",
             "windows", "uia", "uiaFromPoint", "uiaFocused", "waitForIdle", "clipRead",
             "selftest", "indicator", "waitStable", "waitChange", "focus", "frameSig", "probe"
         };
@@ -2841,16 +3187,44 @@ namespace DshComputerUse.Worker
             "activate", "windowOp", "calibrate", "selectRange", "uiaAct"
         };
         static readonly object InputLock = new object();
+        static readonly DesktopOwnershipLease DesktopLease = new DesktopOwnershipLease(DesktopOwnershipLease.DefaultPath());
+        static bool _releaseDesktopPending;
+        public static bool DesktopOwned { get { return DesktopLease.Owned; } }
+        public static bool TryClaimDesktop(string owner)
+        { string occupiedBy; return DesktopLease.TryAcquire(owner, out occupiedBy); }
+        static void EnsureDesktopOwnership(string op)
+        {
+            if (op == "ping" || op == "echoargs" || op == "keyClass" || op == "stuckPlan" || op == "probe") return;
+            string occupiedBy;
+            if (!DesktopLease.TryAcquire("native cycle: " + op, out occupiedBy))
+            {
+                var error = InputInterrupted("MACHINE_OWNED", "Another agent owns this desktop's computer-use cycle (" + occupiedBy + "). This operation was not dispatched; keep the task pending until that cycle releases control.");
+                error.Data["outcome"] = "not-dispatched"; throw error;
+            }
+        }
+        public static void ReleaseDesktopOwnership()
+        {
+            lock (InputLock)
+            {
+                _releaseDesktopPending = true;
+                if (!_operationLive && OwnedUps.Count == 0) { DesktopLease.Dispose(); _releaseDesktopPending = false; }
+            }
+        }
         static readonly Dictionary<string, INPUT> OwnedUps = new Dictionary<string, INPUT>();
         static readonly ConcurrentDictionary<int, bool> CancelledRequests = new ConcurrentDictionary<int, bool>();
         static long _cancelGeneration;
+        public static void InvalidateActiveInput() { Interlocked.Increment(ref _cancelGeneration); }
         static long _operationCancelGeneration, _operationHumanRevision;
         static volatile bool _operationLive, _operationDispatched;
+        static bool _operationActing;
+        static string _lastAnnouncedSeries;
+        static long _announcedHumanRevision, _announcedInputEpoch, _preparedInputEpoch;
         static volatile int _activeRequestId, _lastCompletedRequestId;
         // The seam is internal to the compiled program; no tool can replace it.
         internal static Func<INPUT[], uint> InputSender = delegate(INPUT[] inputs) {
             return Native.SendInput((uint)inputs.Length, inputs, InputCbSize);
         };
+        internal static Func<IntPtr> PreparationForeground = delegate { return Native.GetForegroundWindow(); };
 
         static Exception InputInterrupted(string code, string message)
         {
@@ -2861,16 +3235,89 @@ namespace DshComputerUse.Worker
         }
         public static void CheckHumanInput()
         {
+            if (Panic.ExitRequested)
+                throw InputInterrupted("CYCLE-ENDED", "Ctrl+Alt+Q requested exit; no further input will be sent for this operation.");
             if (Panic.PauseRequested)
                 throw InputInterrupted("ABORTED", "Ctrl+Esc requested a manual pause; wait for manual recovery.");
             if (_operationLive && _operationCancelGeneration != Interlocked.Read(ref _cancelGeneration))
                 throw InputInterrupted("INPUT_CANCELLED", "the owning tool was cancelled; no further input will be sent.");
             if (Panic.HumanActive || (_operationLive && _operationHumanRevision != Panic.HumanRevision))
-                throw InputInterrupted("HUMAN_YIELD", "Physical input owns the desktop. Wait for three quiet seconds, then inspect the current target before continuing; never replay a partial write.");
+                throw InputInterrupted("HUMAN_YIELD", "Temporary interruption only: the user currently owns input and the original task remains active. Wait locally until control returns after three quiet seconds, then immediately obtain fresh target evidence and continue the remaining authorized task. Do not abandon, cancel or declare completion; never replay a partial write.");
         }
         static void MarkMutation()
         {
-            Panic.Check("actuation"); CheckHumanInput(); _operationDispatched = true;
+            Panic.Check("actuation"); BeginActuation(); CheckHumanInput(); _operationDispatched = true;
+        }
+        static void BeginActuation()
+        {
+            if (_operationActing) return;
+            if (_operationLive && _preparedInputEpoch != Panic.InputEpoch)
+                throw InputInterrupted("HUMAN_REOBSERVE", "The user changed the desktop before input began. No action was dispatched. Obtain fresh target evidence and continue the original task; this is a temporary checkpoint, not cancellation.");
+            _operationActing = true;
+            Panic.BeginActuation();
+            CheckHumanInput();
+            if (_operationLive && _preparedInputEpoch != Panic.InputEpoch)
+                throw InputInterrupted("HUMAN_REOBSERVE", "The desktop changed at the input boundary. No action was dispatched. Read the current target and continue the pending task.");
+        }
+        static void EndActuationForReadback()
+        {
+            lock (InputLock)
+            {
+                // Nested selection/chord helpers may still own a modifier or button.
+                // Keep their sequence protected until every accepted down is released.
+                if (OwnedUps.Count != 0) return;
+                _operationActing = false;
+                Panic.EndActuation();
+            }
+        }
+        static void PrepareActuation(string op, Dictionary<string, object> request)
+        {
+            object raw;
+            var args = request.TryGetValue("args", out raw) ? raw as Dictionary<string, object> : null;
+            string series = args == null ? "" : GetS(args, "__inputSeries", "");
+            if (!string.IsNullOrEmpty(series) && series == _lastAnnouncedSeries &&
+                _announcedHumanRevision == Panic.HumanRevision)
+            {
+                if (_announcedInputEpoch != Panic.InputEpoch)
+                    throw InputInterrupted("HUMAN_REOBSERVE", "The user changed the desktop between batch steps. Obtain fresh target evidence and continue the remaining task without replaying completed input.");
+                _preparedInputEpoch = Panic.InputEpoch; return;
+            }
+            Panic.Check(op); CheckHumanInput();
+            long inputEpoch = Panic.InputEpoch;
+            IntPtr foreground = PreparationForeground();
+            Glow.Prepare(true);
+            try
+            {
+                var startup = Stopwatch.StartNew();
+                while (!Glow.PreparationVisible)
+                {
+                    Panic.Check(op); CheckHumanInput();
+                    if (startup.ElapsedMilliseconds >= 5000) throw PreparationUnavailable("first-frame");
+                    Thread.Sleep(10);
+                }
+                var timer = Stopwatch.StartNew();
+                while (timer.ElapsedMilliseconds < Glow.PreparationMs || !Glow.PreparationComplete)
+                {
+                    Panic.Check(op); CheckHumanInput();
+                    if (timer.ElapsedMilliseconds >= 5000) throw PreparationUnavailable("countdown-frame");
+                    int remaining = Glow.PreparationMs - (int)timer.ElapsedMilliseconds;
+                    Thread.Sleep(remaining > 0 ? Math.Min(25, remaining) : 10);
+                }
+                Panic.Check(op); CheckHumanInput();
+                if (inputEpoch != Panic.InputEpoch || foreground != PreparationForeground())
+                    throw InputInterrupted("HUMAN_REOBSERVE", "The user changed the desktop during the preparation cue. No action was dispatched. Preserve the task, obtain fresh target evidence, and continue the authorized task immediately; this is not cancellation or abandonment.");
+                _lastAnnouncedSeries = series; _announcedHumanRevision = Panic.HumanRevision;
+                _announcedInputEpoch = _preparedInputEpoch = inputEpoch;
+            }
+            finally { Glow.Prepare(false); }
+        }
+        static Exception PreparationUnavailable(string phase)
+        {
+            var health = Glow.Health();
+            health["failurePhase"] = phase;
+            var error = InputInterrupted("PREPARATION_UNAVAILABLE", "The preparation notice could not be displayed through completion; no input was dispatched. glowHealth=" + Json.Serialize(health));
+            error.Data["glowHealth"] = health;
+            return error;
         }
         public static bool CancelInput(int requestId)
         {
@@ -2912,6 +3359,7 @@ namespace DshComputerUse.Worker
                 // cross-process STOP may hold SyncLock while releasing owned input.
                 if (Panic.Engaged || Panic.Stopped || Panic.Exited)
                     throw InputInterrupted("ABORTED", "manual pause or exit owns the desktop; no further input will be sent.");
+                BeginActuation();
                 if (inputs.Length == 1)
                 {
                     bool isUp; INPUT release; int physical;
@@ -3106,6 +3554,10 @@ namespace DshComputerUse.Worker
                     else if (kind == "resume")
                         hint = "Re-armed: a human pressed Ctrl+Alt+R (the worker notifies `resume` from Clear() " +
                                "alone) — working may continue from the break point.";
+                    else if (kind == "secure")
+                        hint = why == "active"
+                            ? "The Windows secure desktop is up (a UAC prompt or the lock screen). Input dispatch is PAUSED — nothing you send will be dispatched until it closes. Tell the human a system dialog needs their answer; dispatch resumes automatically the moment the normal desktop returns, then simply retry the step."
+                            : "The normal desktop is back. Input dispatch has resumed automatically — retry the interrupted step and continue the task.";
                     else
                         hint = "worker state change \"" + kind + "\": " + why;
                     WriteLine(Json.Serialize(Dict(
@@ -3136,6 +3588,11 @@ namespace DshComputerUse.Worker
                 Dictionary<string, object> resp;
                 try { resp = Handle(oneshot); }
                 catch (Exception ex) { resp = Err(ex); }
+                if (!Panic.FinishOneShotControls())
+                {
+                    Program.AuditRecord("CONTROL-DRAIN-TIMEOUT", "one-shot control finalization exceeded 5s");
+                    resp = Err("CONTROL-DRAIN-TIMEOUT: physical brake finalization could not be confirmed; verify STOP/EXITED before continuing.");
+                }
                 AuditActuation(oneshot, resp);
                 WriteLine(Json.Serialize(resp));
                 return 0;
@@ -3218,20 +3675,30 @@ namespace DshComputerUse.Worker
         {
             var request = Json.Deserialize<Dictionary<string, object>>(line);
             string op = GetS(request, "op", "");
-            bool input = ActOps.Contains(op) || op == "shiftClick" || op == "selftest";
+            object rawArgs;
+            var args = request.TryGetValue("args", out rawArgs) ? rawArgs as Dictionary<string, object> : null;
+            bool input = ActOps.Contains(op) || op == "shiftClick" || op == "selftest" ||
+                (op == "focus" && args != null && GetB(args, "refocus", false));
+            bool dryInput = input && args != null && GetB(args, "dryRun", false);
+            // Only the coordinate click probe has a native read-only implementation.
+            // No other input may use the flag to skip the controls and then dispatch.
+            if (dryInput && (op != "click" || !args.ContainsKey("x") || !args.ContainsKey("y")))
+                return Err("UNSUPPORTED_DRY_RUN: native input simulation requires a click with x and y; no input was dispatched.");
+            EnsureDesktopOwnership(op);
             int requestId = GetI(request, "id", 0);
             bool ignored;
             _activeRequestId = requestId;
             _operationHumanRevision = Panic.HumanRevision;
             _operationCancelGeneration = Interlocked.Read(ref _cancelGeneration);
             _operationDispatched = false; _operationLive = input;
+            bool scopedCycle = false;
             try
             {
                 if (CancelledRequests.TryRemove(requestId, out ignored))
                     throw InputInterrupted("INPUT_CANCELLED", "cancelled before dispatch.");
                 if (input) CheckHumanInput();
                 string pauseId = Panic.TemporaryPauseId;
-                Dictionary<string, object> result = HandleCore(line);
+                Dictionary<string, object> result = HandleCore(line, input, dryInput, ref scopedCycle);
                 if (input) CheckHumanInput();
                 if (!string.IsNullOrEmpty(pauseId) && GetB(result, "ok", false) &&
                     (op == "windows" || op == "uia" || op == "uiaFromPoint" || op == "uiaFocused" || op == "capture"))
@@ -3240,14 +3707,20 @@ namespace DshComputerUse.Worker
             }
             finally
             {
-                if (input) ReleaseOwnedInputs();
+                if (input)
+                {
+                    try { ReleaseOwnedInputs(); }
+                    finally { _operationActing = false; Panic.EndActuation(); Glow.Prepare(false); }
+                }
                 _operationLive = false; _activeRequestId = 0;
+                if (scopedCycle) Panic.TryEndCycle();
+                if (_releaseDesktopPending) ReleaseDesktopOwnership();
                 _lastCompletedRequestId = Math.Max(_lastCompletedRequestId, requestId);
                 CancelledRequests.TryRemove(requestId, out ignored);
             }
         }
 
-        static Dictionary<string, object> HandleCore(string line)
+        static Dictionary<string, object> HandleCore(string line, bool input, bool dryInput, ref bool scopedCycle)
         {
             Dictionary<string, object> req;
             try { req = Json.Deserialize<Dictionary<string, object>>(line); }
@@ -3257,6 +3730,7 @@ namespace DshComputerUse.Worker
             Dictionary<string, object> a = (req.TryGetValue("args", out av) && av is Dictionary<string, object>) ? (Dictionary<string, object>)av : new Dictionary<string, object>();
             bool cycleOp = GetB(a, "__cycle", false) && op != null &&
                 op != "abort" && op != "ping" && op != "echoargs" &&
+                op != "probe" && op != "keyClass" && op != "stuckPlan" &&
                 op != "indicator" && op != "calm" && op != "panic" && op != "resume" && op != "recover" &&
                 // ... AND THE CYCLE HAS TO BE ALIVE TO BE LIT (2026-09-13). "Lit by any call" is how
                 // a DEAD cycle came back as a cyan breathing border: after Ctrl+Alt+Q ended the
@@ -3279,7 +3753,22 @@ namespace DshComputerUse.Worker
             // human re-arms it (CheckOp's allowlist keeps the health probe and re-arm alive).
             // Emergency stop gates EVERY op that could drive the machine; a DRY RUN drives nothing
             // and is therefore treated as the observation it really is.
-            Panic.CheckOp((op == "click" || op == "move" || op == "type" || op == "key") && GetB(a, "dryRun", false) ? "probe" : op);
+            Panic.CheckOp(dryInput ? "probe" : op);
+
+                if (input && !dryInput)
+                {
+                    // Direct native input (including --op) has no JS cycle signature.
+                    // Arm physical controls before the purple cue and release this scope
+                    // when the request ends. A human pause or exit retains its own latch.
+                    if (!Panic.CycleLit)
+                    {
+                        scopedCycle = Panic.TryLightCycle(0);
+                        if (!scopedCycle) Panic.Check(op);
+                    }
+                    Panic.RequireControlHooks();
+                    Panic.RequireNormalDesktop();
+                    PrepareActuation(op, req);
+                }
 
             switch (op)
             {
@@ -3291,7 +3780,7 @@ namespace DshComputerUse.Worker
                 case "beginAsk": return Ok(BeginAskOp(a));
                 case "endAsk": return Ok(EndAskOp(a));
                 case "exit": return Ok(ExitOp(a));
-                case "ping": return Ok(Dict("pong", true, "cooperation", Panic.CooperationState()));
+                case "ping": return Ok(Dict("pong", true, "cooperation", Panic.CooperationState(), "glowHealth", Glow.Health()));
                 // TEST SEAM (D, 2026-09-13). A fixture may not re-implement the rule it measures, so
                 // this op drives the PRODUCTION transition (Panic.ClassifyAndTrackKey — the same
                 // function the low-level hook calls) with explicit evidence: ours / injected / vk.
@@ -3357,6 +3846,7 @@ namespace DshComputerUse.Worker
                 case "screens": return Ok(VirtualScreenDict());
                 case "cursor": POINT cp; Native.GetCursorPos(out cp); return Ok(PtDict(cp.X, cp.Y));
                 case "capture": return Ok(Capture(a));
+                case "ocr": return Ok(Ocr(a));
                 case "annotate": return Ok(Annotate(a));
                 case "move": FailsafeCheck(a); return Ok(Move(a));
                 case "click": FailsafeCheck(a); return Ok(Click(a));
@@ -3378,13 +3868,15 @@ namespace DshComputerUse.Worker
                 case "probe":
                 {
                     string what = GetS(a, "what", "point");
-                    Dictionary<string, object> pr = what == "focus" ? ProbeFocus()
+                    Dictionary<string, object> pr = what == "glow" ? Dict() : what == "focus" ? ProbeFocus()
                         : (what == "window" ? WinBrief(FindHwnd(a)) : ProbePoint(GetI(a, "x", 0), GetI(a, "y", 0)));
+                    pr["glowHealth"] = Glow.Health();
                     // The state machine as a FACT, in the one op that exists to answer "what is
                     // actually true right now". Read-only, so asking never changes the answer.
                     pr["cycle"] = Dict(
                         "cycleLit", Panic.CycleLit,
                         "armed", Panic.Armed,
+                        "secureDesktop", Panic.SecureDesktopActive,
                         "engaged", Panic.Engaged,
                         "stopped", Panic.Stopped,
                         "exited", Panic.Exited,
@@ -3399,8 +3891,9 @@ namespace DshComputerUse.Worker
                     pr["glow"] = Dict(
                         "want", Glow.Want,
                         // Is a real injection sequence in flight RIGHT NOW? The ACTING light is driven
-                        // by this as well as by its short tail, so the state is reported as a fact.
+                        // by the actual action scope, so both are reported as observable facts.
                         "injecting", Glow.Injecting,
+                        "acting", Glow.Acting, "preparing", Glow.Preparing, "preparationMs", Glow.PreparationMs,
                         "title", Glow.ShownTitle == null ? "" : Glow.ShownTitle);
                     // EVENTS THE OS ACTUALLY INSERTED (not the plan): 0 after a plain pause with
                     // nothing held is the observable form of "no ghost right-click / Alt menu".
@@ -3417,9 +3910,9 @@ namespace DshComputerUse.Worker
                 // like the emergency brake. Called when the agent's turn ends, so a lingering blue
                 // border can never claim the machine is still being driven after control stopped.
                 case "calm":
-                    Panic.CycleLit = false;  // the turn is over: the cycle is dead (R2)
-                    Panic.Disarm();          // the human monitors stop WITH it
-                    Glow.Kill(); return Ok(Dict("indicator", "off", "hard", true));
+                    if (!Panic.TryEndCycle())
+                        return Ok(Dict("released", false, "reason", "A manual pause or question still owns this cycle; its brake and ownership were preserved."));
+                    return Ok(Dict("released", true, "indicator", "off", "hard", true));
                 case "focus": return Ok(FocusReport(a, GetB(a, "refocus", false)));
                 case "frameSig": return Ok(FrameSigOp(a));
                 // `source=agent` (not "unknown"): this op exists ONLY for the agent's own `stop`, and a
@@ -3465,6 +3958,90 @@ namespace DshComputerUse.Worker
 
         static long NowMs() { return (long)(DateTime.UtcNow - Epoch).TotalMilliseconds; }
 
+        // ---------- OCR: text WITH bounding boxes, straight from the worker ----------
+        // Zero-UIA apps (WeChat incident 2026-11-04) burned one screenshot per decision because
+        // finding "傳送" or a contact name meant reading pixels with model vision. Windows' inbox
+        // OCR (Windows.Media.Ocr — ships with the OS, zero external dependencies) returns text
+        // with per-word rectangles, so the model can locate controls BY NAME and spend vision
+        // only where looks actually matter. Coordinates are ABSOLUTE screen pixels (region origin
+        // added), ready for computer_click without further math.
+        static OcrEngine _ocrEngine;
+        static string _ocrLanguage;
+        static Dictionary<string, object> Ocr(Dictionary<string, object> a)
+        {
+            ValidateKickoffCapture(a);
+            if (_ocrEngine == null)
+            {
+                _ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
+                if (_ocrEngine != null) _ocrLanguage = _ocrEngine.RecognizerLanguage.LanguageTag;
+            }
+            if (_ocrEngine == null)
+                throw new Exception("OCR_UNAVAILABLE: no OCR recognizer language is installed on this machine. " +
+                    "Install one (Settings > Time & language > Language > add a language with 'Text recognition') " +
+                    "or read regions with computer_shot instead.");
+            int vx = Native.GetSystemMetrics(Native.SM_XVIRTUALSCREEN);
+            int vy = Native.GetSystemMetrics(Native.SM_YVIRTUALSCREEN);
+            int vw = Native.GetSystemMetrics(Native.SM_CXVIRTUALSCREEN);
+            int vh = Native.GetSystemMetrics(Native.SM_CYVIRTUALSCREEN);
+            int x = GetI(a, "x", vx), y = GetI(a, "y", vy);
+            int w = GetI(a, "width", vw), h = GetI(a, "height", vh);
+            if (GetB(a, "clamp", true))
+            {
+                int x2 = Math.Max(x, vx), y2 = Math.Max(y, vy);
+                int x3 = Math.Min(x + w, vx + vw), y3 = Math.Min(y + h, vy + vh);
+                if (x3 <= x2 || y3 <= y2) throw new Exception("region outside virtual desktop");
+                x = x2; y = y2; w = x3 - x2; h = y3 - y2;
+            }
+            // OCR cost scales with pixels; one decision never needs more than 16M of them.
+            if ((long)w * h > 16L * 1024 * 1024)
+                throw new Exception("OCR region exceeds 16M pixels (" + w + "x" + h + "); crop tighter.");
+            byte[] bgra = new byte[w * h * 4];
+            IntPtr screen = IntPtr.Zero, mem = IntPtr.Zero, dib = IntPtr.Zero, oldBmp = IntPtr.Zero;
+            try
+            {
+                screen = Native.GetDC(IntPtr.Zero);
+                mem = Native.CreateCompatibleDC(screen);
+                Native.BITMAPINFO bmi = new Native.BITMAPINFO();
+                bmi.bmiHeader.biSize = (uint)Marshal.SizeOf(typeof(Native.BITMAPINFOHEADER));
+                bmi.bmiHeader.biWidth = w; bmi.bmiHeader.biHeight = -h;   // top-down
+                bmi.bmiHeader.biPlanes = 1; bmi.bmiHeader.biBitCount = 32;
+                bmi.bmiHeader.biCompression = 0;
+                IntPtr bits;
+                dib = Native.CreateDIBSection(screen, ref bmi, 0, out bits, IntPtr.Zero, 0);
+                if (dib == IntPtr.Zero) throw new Exception("OCR: CreateDIBSection failed");
+                oldBmp = Native.SelectObject(mem, dib);
+                Native.BitBlt(mem, 0, 0, w, h, screen, x, y, 0x00CC0020 | 0x40000000);
+                Marshal.Copy(bits, bgra, 0, bgra.Length);
+            }
+            finally
+            {
+                if (oldBmp != IntPtr.Zero && oldBmp != new IntPtr(-1)) Native.SelectObject(mem, oldBmp);
+                if (dib != IntPtr.Zero) Native.DeleteObject(dib);
+                if (mem != IntPtr.Zero) Native.DeleteDC(mem);
+                if (screen != IntPtr.Zero) Native.ReleaseDC(IntPtr.Zero, screen);
+            }
+            SoftwareBitmap bitmap = SoftwareBitmap.CreateCopyFromBuffer(
+                WindowsRuntimeBufferExtensions.AsBuffer(bgra), BitmapPixelFormat.Bgra8, w, h);
+            OcrResult result = _ocrEngine.RecognizeAsync(bitmap).AsTask().GetAwaiter().GetResult();
+            List<object> lines = new List<object>();
+            StringBuilder joined = new StringBuilder();
+            foreach (OcrLine line in result.Lines)
+            {
+                List<object> words = new List<object>();
+                foreach (OcrWord word in line.Words)
+                {
+                    words.Add(Dict("text", word.Text,
+                        "x", x + (int)word.BoundingRect.X, "y", y + (int)word.BoundingRect.Y,
+                        "w", (int)word.BoundingRect.Width, "h", (int)word.BoundingRect.Height));
+                }
+                lines.Add(Dict("text", line.Text, "words", words));
+                if (joined.Length > 0) joined.Append('\n');
+                joined.Append(line.Text);
+            }
+            return Dict("lines", lines, "text", joined.ToString(), "language", _ocrLanguage,
+                "region", new int[] { x, y, w, h });
+        }
+
         static Dictionary<string, object> Capture(Dictionary<string, object> a)
         {
             ValidateKickoffCapture(a); // before even the pixel-stability sampler
@@ -3706,6 +4283,7 @@ namespace DshComputerUse.Worker
             // ACTING light on it, and clear the mark in a finally so the blue can never outlive the
             // input it is describing.
             CheckHumanInput();
+            BeginActuation();
             Glow.InputBegin();
             try
             {
@@ -3767,7 +4345,8 @@ namespace DshComputerUse.Worker
             string btn = GetS(a, "button", "left");
             int clicks = Math.Max(1, Math.Min(3, GetI(a, "clicks", 1)));
             int gap = GetI(a, "intervalMs", 60);
-            AgentActing(a, "click");
+            bool dryRun = GetB(a, "dryRun", false);
+            if (!dryRun) AgentActing(a, "click");
             CheckHumanInput();
             // If the caller NAMED the window it wants to click in, put that window in front
             // first: a click on a covered pixel is delivered to whatever is on top of it (the
@@ -3778,7 +4357,6 @@ namespace DshComputerUse.Worker
             // would change the thing it measures. That bug hid a real occlusion for a whole test
             // round (2026-09-13): every dry run reported "ok" because it had just activated the
             // window it was asked about.
-            bool dryRun = GetB(a, "dryRun", false);
             // A caller-supplied window is re-asserted (raised, ALT tap, titlebar click) on the
             // next line, so it has to be checked BEFORE that: the pixel check further down comes
             // far too late to protect a window the worker was told to bring forward.
@@ -3921,6 +4499,7 @@ namespace DshComputerUse.Worker
                 SendMouse(down, 0, 0, 0); Thread.Sleep(30); SendMouse(up, 0, 0, 0);
                 if (i < clicks - 1) Thread.Sleep(gap);
             }
+            EndActuationForReadback();
             double changedPct = -1;
             if (verify && before != null)
             {
@@ -3940,8 +4519,10 @@ namespace DshComputerUse.Worker
             {
                 clickOut["changedPct"] = changedPct;
                 if (changedPct < 0.15 && !a.ContainsKey("verify"))
-                    clickOut["warning"] = "nothing changed near the click point within ~240ms: the click may not have reached " +
-                        "its target (dead UI, disabled control, or a wrong pixel). Probe the point before retrying.";
+                    clickOut["warning"] = "nothing changed near the click point within ~240ms. This is EXPECTED when the " +
+                        "click lands on an already-focused editor or a control already in the desired state (a caret blink " +
+                        "alone sits below the threshold — test report 2026-11-04); it can also mean a dead/disabled control " +
+                        "or a wrong pixel. Read focus/receiver above and only retry if they disagree with the intent.";
             }
             return clickOut;
         }
@@ -4047,16 +4628,8 @@ namespace DshComputerUse.Worker
             {
                 _lastRefocus = EnsureTargetForeground();
             }
-            // Stays lit across the agent's thinking gaps: the glow means "the agent is
-            // driving this machine right now", not "a click happened a moment ago".
-            // 1200 ms, not 30000 (2026-09-13). The hold is how long the DEEP BLUE "acting" border
-            // stays after an input injection — and 30 s meant a 50 ms click painted half a minute of
-            // "I am driving the machine", during which the cyan "thinking" state could never show
-            // (the render loop shows acting in preference to thinking). The human watched the blue
-            // light sit still through a whole page read and asked, correctly, why. Blue now means
-            // "input, right now, plus a short tail"; cyan is what a reading agent looks like.
-            int hold = GetI(a, "indicatorMs", 1200);
-            Glow.Touch(hold);
+            // Validation and focus readback do not own input. The first real mutation
+            // or SendInput opens the actual scope and its deep-blue cue.
         }
 
         static Dictionary<string, object> Indicator(Dictionary<string, object> a)
@@ -4360,11 +4933,16 @@ namespace DshComputerUse.Worker
 
         // Explicit window scope excludes unrelated desktop animation without loosening the
         // change threshold. A moved/minimized/replaced window invalidates the observation.
-        static Func<byte[]> WaitSampler(Dictionary<string, object> a, int step, out object scope)
+        static Func<byte[]> WaitSampler(Dictionary<string, object> a, int step, out object scope,
+            out int rx, out int ry, out int rw, out int rh)
         {
             if (!a.ContainsKey("hwnd") || GetI(a, "hwnd", 0) == 0)
             {
-                scope = Dict("kind", "virtual-desktop");
+                rx = Native.GetSystemMetrics(Native.SM_XVIRTUALSCREEN);
+                ry = Native.GetSystemMetrics(Native.SM_YVIRTUALSCREEN);
+                rw = Native.GetSystemMetrics(Native.SM_CXVIRTUALSCREEN);
+                rh = Native.GetSystemMetrics(Native.SM_CYVIRTUALSCREEN);
+                scope = Dict("kind", "virtual-desktop", "region", Dict("x", rx, "y", ry, "width", rw, "height", rh));
                 return delegate { return FrameSignature(step); };
             }
             IntPtr h = new IntPtr(GetI(a, "hwnd", 0));
@@ -4376,7 +4954,8 @@ namespace DshComputerUse.Worker
             Rectangle visible = Rectangle.Intersect(virtualRect, Rectangle.FromLTRB(original.Left, original.Top, original.Right, original.Bottom));
             if (visible.Width <= 16 || visible.Height <= 16)
                 throw new Exception("WAIT_TARGET_UNAVAILABLE: window has no usable visible screen region");
-            scope = Dict("kind", "window", "hwnd", h.ToInt64(), "region", Dict("x", visible.X, "y", visible.Y, "width", visible.Width, "height", visible.Height));
+            rx = visible.X; ry = visible.Y; rw = visible.Width; rh = visible.Height;
+            scope = Dict("kind", "window", "hwnd", h.ToInt64(), "region", Dict("x", rx, "y", ry, "width", rw, "height", rh));
             return delegate {
                 RECT current;
                 if (!Native.IsWindow(h) || Native.IsIconic(h) || PidOf(h) != pid || !Native.GetWindowRect(h, out current) ||
@@ -4386,6 +4965,29 @@ namespace DshComputerUse.Worker
             };
         }
 
+        /// Bounding box (absolute screen px) of every signature cell that differs beyond the
+        /// threshold — "where did it change", not just "did it" (test report 2026-11-04: a
+        /// 0.344% diff cannot distinguish a sent message from a blinking caret without this).
+        static int[] SigDiffBounds(byte[] a, byte[] b, int threshold, int cols, int step, int rx, int ry)
+        {
+            if (a == null || b == null || a.Length != b.Length || cols <= 0) return null;
+            int minX = -1, minY = -1, maxX = -1, maxY = -1;
+            for (int i = 0; i < a.Length; i++)
+            {
+                int d = a[i] - b[i];
+                if (d < 0) d = -d;
+                if (d <= threshold) continue;
+                int c = i % cols, r = i / cols;
+                if (minX < 0 || c < minX) minX = c;
+                if (c > maxX) maxX = c;
+                if (minY < 0 || r < minY) minY = r;
+                if (r > maxY) maxY = r;
+            }
+            if (minX < 0) return null;
+            return new int[] { rx + minX * step, ry + minY * step,
+                (maxX - minX + 1) * step, (maxY - minY + 1) * step };
+        }
+
         static Dictionary<string, object> WaitStable(Dictionary<string, object> a)
         {
             int capMs = Math.Max(400, GetI(a, "timeoutMs", 8000));
@@ -4394,8 +4996,34 @@ namespace DshComputerUse.Worker
             int step = Math.Max(4, Math.Min(64, GetI(a, "step", 8)));
             double diffPct = GetD(a, "diffPct", 0.30);
             int waited, estimate; double lastDiff;
-            object scope; Func<byte[]> sample = WaitSampler(a, step, out scope);
+            int rx, ry, rw, rh;
+            object scope; Func<byte[]> sample = WaitSampler(a, step, out scope, out rx, out ry, out rw, out rh);
             bool ok = SettleSampleWait(capMs, stableMs, pollMs, diffPct, sample, out waited, out lastDiff, out estimate);
+            if (!ok)
+            {
+                // CARET / BLINK DETECTION (test report 2026-11-04): a blinking caret is a ~1-2 Hz
+                // periodic sub-percent change that never settles — Notepad burned the full 8 s cap
+                // on lastDiffPct 0.388%. Probe one extra window (~2.4 s covers several blink
+                // cycles): if EVERY consecutive diff is tiny but nonzero, the only motion is the
+                // caret — call it stable and say exactly why.
+                int probes = Math.Max(6, 2400 / pollMs);
+                byte[] prev = sample();
+                double max = 0; bool zero = false, large = false;
+                for (int i = 0; i < probes; i++)
+                {
+                    Thread.Sleep(pollMs);
+                    byte[] cur = sample();
+                    double d = SigDiffPct(prev, cur, 8);
+                    prev = cur;
+                    if (d == 0) zero = true;
+                    if (d > 1.0) large = true;
+                    if (d > max) max = d;
+                }
+                if (!large && !zero && max < 1.0)
+                    return Dict("stable", true, "waitedMs", waited, "lastDiffPct", Math.Round(max, 3),
+                        "estimateMs", estimate, "scope", scope, "caretSteady", true,
+                        "note", "the only sampled motion is a small periodic change consistent with a blinking caret (~1-2 Hz); treated as stable. lastDiffPct here is the LARGEST probe difference. This still does not verify task completion.");
+            }
             return Dict("stable", ok, "waitedMs", waited, "lastDiffPct", Math.Round(lastDiff, 3),
                         "estimateMs", estimate, "scope", scope,
                         "note", ok ? "sampled pixels settled; this does not verify task completion"
@@ -4408,10 +5036,12 @@ namespace DshComputerUse.Worker
             int pollMs = Math.Max(100, GetI(a, "pollMs", 220));
             int step = Math.Max(4, Math.Min(64, GetI(a, "step", 8)));
             double diffPct = GetD(a, "diffPct", 0.30);
-            object scope; Func<byte[]> sample = WaitSampler(a, step, out scope);
+            int rx, ry, rw, rh;
+            object scope; Func<byte[]> sample = WaitSampler(a, step, out scope, out rx, out ry, out rw, out rh);
             byte[] first = sample();
             long t0 = NowMs();
             int samples = 0;
+            int cols = (rw - 1) / step + 1;
             while (NowMs() - t0 < timeoutMs)
             {
                 Thread.Sleep(pollMs);
@@ -4419,7 +5049,15 @@ namespace DshComputerUse.Worker
                 samples++;
                 double d = SigDiffPct(first, cur, 8);
                 if (d > diffPct)
-                    return Dict("changed", true, "afterMs", NowMs() - t0, "diffPct", Math.Round(d, 3), "samples", samples, "scope", scope);
+                {
+                    // WHERE it changed (test report 2026-11-04): 0.344% cannot tell a sent
+                    // message from a caret blink; the bounding box can — input area vs caret.
+                    int[] bounds = SigDiffBounds(first, cur, 8, cols, step, rx, ry);
+                    Dictionary<string, object> hit = Dict("changed", true, "afterMs", NowMs() - t0,
+                        "diffPct", Math.Round(d, 3), "samples", samples, "scope", scope);
+                    if (bounds != null) hit["changeBounds"] = Dict("x", bounds[0], "y", bounds[1], "width", bounds[2], "height", bounds[3]);
+                    return hit;
+                }
             }
             return Dict("changed", false, "afterMs", NowMs() - t0, "samples", samples, "scope", scope,
                         "note", "no sampled pixel change exceeded the threshold; inspect task state before retrying a write");
@@ -4665,6 +5303,7 @@ namespace DshComputerUse.Worker
             KeyboardChord.Run(vks, SendKey, ReleaseKeyForCleanup,
                 delegate(ushort vk) { return (Native.GetAsyncKeyState(vk) & 0x8000) != 0; },
                 delegate { WaitForKeyHold(Math.Max(20, GetI(a, "holdMs", 60))); });
+            EndActuationForReadback();
             Thread.Sleep(30);
             Dictionary<string, object> keyOut = Dict("combo", combo, "focus", focus);
             if (_lastRefocus != null) keyOut["refocused"] = _lastRefocus;
@@ -4717,6 +5356,24 @@ namespace DshComputerUse.Worker
                     {
                         CheckHumanInput();
                         ClipboardLease lease = ClipboardLease.Begin(access, text);
+                        if (lease == null)
+                        {
+                            // UNPRESERVABLE CLIPBOARD, 2026-11-04: the previous clipboard holds
+                            // private/oversized content we cannot snapshot. Overwrite and paste
+                            // anyway — a lost opaque clipboard item is recoverable, while the old
+                            // refusal fed CJK text to the unicode fallback and an IME-garbled
+                            // message actually went out (WeChat, format 49161).
+                            MarkMutation();
+                            Clipboard.SetDataObject(text, true);
+                            Thread.Sleep(60);
+                            Key(Dict("combo", "ctrl+v", "holdMs", 40, "indicatorMs", 800));
+                            Dictionary<string, object> downgraded = Dict("mode", "paste", "chars", text.Length, "focus", focus,
+                                "clipboardRestore", "skipped-unpreservable-clipboard");
+                            downgraded["clipboardWarning"] = "The previous clipboard could not be preserved (private or oversized formats) and was overwritten by this paste. Restore it manually if it mattered.";
+                            if (typeWarn != null) downgraded["warning"] = typeWarn;
+                            if (_lastRefocus != null) downgraded["refocused"] = _lastRefocus;
+                            return downgraded;
+                        }
                         Exception inputError = null;
                         try
                         {
@@ -4820,12 +5477,18 @@ namespace DshComputerUse.Worker
 
         static Dictionary<string, object> Windows(Dictionary<string, object> a)
         {
+            uint self = (uint)System.Diagnostics.Process.GetCurrentProcess().Id;
             List<object> list = new List<object>();
             Native.EnumWindows(delegate(IntPtr h, IntPtr l)
             {
                 if (!Native.IsWindowVisible(h)) return true;
                 StringBuilder sb = new StringBuilder(512);
                 if (Native.GetWindowText(h, sb, 512) == 0) return true;
+                // Hide this worker's own click-through indicator overlay (test report 2026-11-04):
+                // it is a full-screen topmost layer, never a target, and listing it only invites
+                // the model to "activate" the thing that must never take focus.
+                uint pid; Native.GetWindowThreadProcessId(h, out pid);
+                if (pid == self) return true;
                 list.Add(WinDict(h));
                 return true;
             }, IntPtr.Zero);
@@ -4886,15 +5549,16 @@ namespace DshComputerUse.Worker
             // The whole ladder now lives in RefocusWindow (shared with the keyboard focus
             // guard, which must re-assert the same window before typing).
             string how = RefocusWindow(h, GetB(a, "clickFallback", true));
-            if (how == null || !Native.IsWindow(h) || !IsForeground(h)) how = "failed";
+            uint confirmedPid = 0;
+            if (how == null || !Native.IsWindow(h) || !IsForeground(h) || (confirmedPid = PidOf(h)) == 0) how = "failed";
             else
             {
                 SetSticky(h);
-                _kickoffFocus.Confirm(h.ToInt64(), PidOf(h));
+                _kickoffFocus.Confirm(h.ToInt64(), confirmedPid);
             }
             CheckHumanInput();
             return Dict("activated", how != "failed", "activatedVia", how,
-                        "hwnd", h.ToInt64(),
+                        "hwnd", h.ToInt64(), "pid", confirmedPid == 0 ? null : (object)confirmedPid,
                         "hint", how == "failed"
                             ? "foreground lock refused every method; click the window (or its taskbar button) and retry"
                             : null);
@@ -4933,13 +5597,21 @@ namespace DshComputerUse.Worker
             IntPtr fg = TopLevel(Native.GetForegroundWindow());
             string problem = _kickoffFocus.CaptureProblem(Panic.CycleLit, Panic.Stopped, Panic.Exited,
                 target != IntPtr.Zero && Native.IsWindow(target), fg.ToInt64(), PidOf(fg), IsHostWindow(fg));
-            if (problem != null) throw new Exception(
-                "KICKOFF-FOCUS-REQUIRED: " + problem + ". No screenshot was returned. " +
-                "First use computer_state {windows:true} to identify the intended app by window/process. " +
-                "Then computer_window {hwnd:...,op:'activate'}: it restores minimized windows and tries " +
-                "the foreground/attachment, topmost and verified-titlebar fallback methods. " +
-                "Require activated:true before taking a screenshot. If activation fails, inspect the text " +
-                "result and re-identify the target; do not treat the agent desktop as the task page.");
+            if (problem != null)
+            {
+                // NAME THE ACTUAL FOREGROUND (test report 2026-11-04): "identify the intended
+                // window" without saying who holds the foreground forced an extra computer_state
+                // round trip just to learn the one fact this refusal already measured.
+                StringBuilder fgTitle = new StringBuilder(256);
+                if (fg != IntPtr.Zero) Native.GetWindowText(fg, fgTitle, fgTitle.Capacity);
+                throw new Exception(
+                    "KICKOFF-FOCUS-REQUIRED: " + problem + ". No screenshot was returned. " +
+                    "Foreground now: hwnd=" + fg.ToInt64() + ", pid=" + PidOf(fg) +
+                    ", title=\"" + fgTitle.ToString() + "\". " +
+                    "If the reported foreground HWND and PID match the target already verified for this task, reactivate it. " +
+                    "Otherwise identify the intended window with computer_state {windows:true}. " +
+                    "Use computer_window {hwnd:...,op:'activate'} and require activated:true before retrying the screenshot.");
+            }
         }
 
         static IntPtr TopLevel(IntPtr h)
@@ -5550,8 +6222,8 @@ namespace DshComputerUse.Worker
         {
             CheckHumanInput();
             if (h == IntPtr.Zero || !Native.IsWindow(h)) return null;
-            if (!Native.IsWindowVisible(h)) Native.ShowWindow(h, Native.SW_SHOWNOACTIVATE);
-            if (Native.IsIconic(h)) Native.ShowWindow(h, Native.SW_RESTORE);
+            if (!Native.IsWindowVisible(h)) { MarkMutation(); Native.ShowWindow(h, Native.SW_SHOWNOACTIVATE); }
+            if (Native.IsIconic(h)) { MarkMutation(); Native.ShowWindow(h, Native.SW_RESTORE); }
             Thread.Sleep(40);
             CheckHumanInput();
             if (IsForeground(h)) return "already-foreground";
@@ -6018,8 +6690,7 @@ namespace DshComputerUse.Worker
                     ", automationId=" + (autoId ?? "-") + ", role=" + (role ?? "-") +
                     ", index=" + index + ") among " + seen + " elements");
 
-            // This changes the UI, so the human gets the cue — but there is no pointer to
-            // fight, so the quiet gate is skipped on purpose.
+            // A UIA mutation shares the same actual-action boundary and takeover checks.
             // A selector WITHOUT hwnd searches the whole desktop, so there the element that
             // actually matched decides the victim - and a host control is never driven through
             // its automation pattern either.
@@ -6028,11 +6699,9 @@ namespace DshComputerUse.Worker
             HostGuardPid(foundPid, "uiaAct");
             Panic.Check("uiaAct");
             CheckHumanInput();
-            Glow.Touch(GetI(a, "indicatorMs", 1200));   // same reason: see AgentActing
 
             object pat = null;
             string via = null;
-            MarkMutation();
             switch (action)
             {
                 case "invoke":
@@ -6064,6 +6733,7 @@ namespace DshComputerUse.Worker
                 default:
                     throw new Exception("action must be invoke|select|expand|collapse|toggle|setValue|focus|scrollIntoView");
             }
+            EndActuationForReadback();
             if (via == null)
                 throw new Exception("element does not support '" + action + "': " + ElemDict(found)["name"]);
 
@@ -6356,6 +7026,7 @@ namespace DshComputerUse.Worker
         static Dictionary<string, object> Err(Exception error)
         {
             var result = Err(error.Message);
+            if (error.Data["glowHealth"] != null) result["glowHealth"] = error.Data["glowHealth"];
             if (error.Data["code"] != null)
             {
                 result["code"] = (string)error.Data["code"];
@@ -6373,3 +7044,79 @@ namespace DshComputerUse.Worker
         static void WriteLine(string s) { lock (OutLock) { Console.Out.WriteLine(s); Console.Out.Flush(); } }
     }
 }
+
+// Integrated verbatim into worker.cs by the native worker build. Tests compile this
+// production class without starting hooks, overlays or desktop input.
+namespace DshComputerUse.Worker
+{
+    public sealed class DesktopOwnershipLease : System.IDisposable
+    {
+        readonly object sync = new object();
+        readonly string path;
+        System.IO.FileStream stream;
+        public DesktopOwnershipLease(string file) { path = file; }
+        public bool Owned { get { lock (sync) { return stream != null; } } }
+        public static string DefaultPath()
+        {
+            string isolated = System.Environment.GetEnvironmentVariable("DSH_COMPUTER_USE_OWNER_FILE");
+            if (!string.IsNullOrEmpty(isolated)) return isolated;
+            return System.IO.Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.LocalApplicationData),
+                "dsh-computer-use", "desktop-" + System.Diagnostics.Process.GetCurrentProcess().SessionId + ".owner");
+        }
+        public bool TryAcquire(string owner, out string occupiedBy)
+        {
+            lock (sync)
+            {
+                occupiedBy = "";
+                if (stream != null) return true;
+                System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(path)));
+                System.IO.FileStream opened;
+                try
+                {
+                    // A persistent handle is the lock. Never delete the pathname, use a
+                    // timer, or steal based on PID: Windows releases it when the process dies.
+                    opened = new System.IO.FileStream(path, System.IO.FileMode.OpenOrCreate,
+                        System.IO.FileAccess.ReadWrite, System.IO.FileShare.Read);
+                }
+                catch (System.IO.IOException error)
+                {
+                    int code = System.Runtime.InteropServices.Marshal.GetHRForException(error) & 0xFFFF;
+                    if (code != 32 && code != 33) throw;
+                    occupiedBy = ReadOwner();
+                    return false;
+                }
+                try
+                {
+                    byte[] record = System.Text.Encoding.UTF8.GetBytes("pid=" + System.Diagnostics.Process.GetCurrentProcess().Id +
+                        "\nowner=" + (owner ?? "worker").Replace("\r", " ").Replace("\n", " ") + "\n");
+                    opened.SetLength(0); opened.Write(record, 0, record.Length); opened.Flush();
+                    stream = opened;
+                    return true;
+                }
+                catch { opened.Dispose(); throw; }
+            }
+        }
+        string ReadOwner()
+        {
+            try
+            {
+                using (var input = new System.IO.FileStream(path, System.IO.FileMode.Open,
+                    System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite))
+                using (var reader = new System.IO.StreamReader(input))
+                {
+                    char[] buffer = new char[512];
+                    return new string(buffer, 0, reader.Read(buffer, 0, buffer.Length)).Trim();
+                }
+            }
+            catch { return "another live computer-use worker"; }
+        }
+        public void Dispose()
+        {
+            lock (sync)
+            {
+                if (stream == null) return;
+                stream.Dispose(); stream = null;
+            }
+        }
+    }
+}