@soederpop/luca 0.0.26 → 0.0.28

package/src/node/features/window-manager.ts

@@ -16,6 +16,10 @@ const DEFAULT_SOCKET_PATH = join(
   'ipc-window.sock'
 )
 
+function controlPathFor(socketPath: string): string {
+  return socketPath.replace(/\.sock$/, '-control.sock')
+}
+
 const ErrorCodes = ['BadRequest', 'NotFound', 'EvalFailed', 'Internal', 'Timeout', 'Disconnected', 'NoClient'] as const
 type WindowManagerErrorCode = typeof ErrorCodes[number]
 
@@ -45,6 +49,24 @@ export const WindowManagerOptionsSchema = FeatureOptionsSchema.extend({
 })
 export type WindowManagerOptions = z.infer<typeof WindowManagerOptionsSchema>
 
+/** One window as tracked in feature state (keys are canonical lowercase ids). */
+export const WindowTrackedEntrySchema = z.object({
+  windowId: z.string().describe('Canonical id (lowercase)'),
+  nativeWindowId: z.string().optional().describe('Last id string from the native app (may differ in casing)'),
+  openedAt: z.number().optional().describe('Epoch ms when this process first recorded the window'),
+  lastAck: z.any().optional().describe('JSON-serializable snapshot of the last relevant ack payload'),
+  kind: z.enum(['browser', 'terminal', 'unknown']).optional().describe('How the window was opened, if known'),
+})
+export type WindowTrackedEntry = z.infer<typeof WindowTrackedEntrySchema>
+
+/** In-flight window IPC op (the Promise + timer remain internal to the feature). */
+export const WindowPendingOperationSchema = z.object({
+  requestId: z.string(),
+  action: z.string().optional(),
+  startedAt: z.number(),
+})
+export type WindowPendingOperation = z.infer<typeof WindowPendingOperationSchema>
+
 export const WindowManagerStateSchema = FeatureStateSchema.extend({
   listening: z.boolean().default(false)
     .describe('Whether the IPC server is listening'),
@@ -53,9 +75,17 @@ export const WindowManagerStateSchema = FeatureStateSchema.extend({
   socketPath: z.string().optional()
     .describe('The socket path in use'),
   windowCount: z.number().default(0)
-    .describe('Number of tracked windows'),
+    .describe('Number of tracked windows (mirrors keys of `windows`)'),
+  windows: z.record(z.string(), WindowTrackedEntrySchema).default({})
+    .describe('Open windows keyed by canonical id'),
+  pendingOperations: z.array(WindowPendingOperationSchema).default([])
+    .describe('Window commands awaiting windowAck'),
+  producerCount: z.number().default(0)
+    .describe('Producer sockets connected to this broker (broker mode only)'),
   lastError: z.string().optional()
     .describe('Last error message'),
+  mode: z.enum(['broker', 'producer']).optional()
+    .describe('Whether this instance is the broker (owns app socket) or a producer (routes through broker)'),
 })
 export type WindowManagerState = z.infer<typeof WindowManagerStateSchema>
 
@@ -65,8 +95,9 @@ export const WindowManagerEventsSchema = FeatureEventsSchema.extend({
   clientDisconnected: z.tuple([]).describe('Emitted when the native app disconnects'),
   message: z.tuple([z.any().describe('The parsed message object')]).describe('Emitted for any incoming message that is not a windowAck'),
   windowAck: z.tuple([z.any().describe('The window ack payload')]).describe('Emitted when a window ack is received from the app'),
-  windowClosed: z.tuple([z.any().describe('Window lifecycle payload emitted when a window closes')]).describe('Emitted when the native app reports a window closed event'),
+  windowClosed: z.tuple([z.any().describe('Lifecycle payload; includes canonical lowercase `windowId` when the closed window can be inferred (from `windowId`, `id`, nested fields, etc.)')]).describe('Emitted when the native app reports a window closed event'),
   terminalExited: z.tuple([z.any().describe('Terminal lifecycle payload emitted when a terminal process exits')]).describe('Emitted when the native app reports a terminal process exit event'),
+  windowFocus: z.tuple([z.any().describe('Focus payload with windowId, kind, focused (boolean), and frame {x, y, width, height}')]).describe('Emitted when a window gains or loses focus'),
   error: z.tuple([z.any().describe('The error')]).describe('Emitted on error'),
 })
 
@@ -180,6 +211,8 @@ export type LayoutEntry =
 interface WindowHandleEvents {
   close: [msg: any]
   terminalExited: [msg: any]
+  focus: [msg: any]
+  blur: [msg: any]
 }
 
 // --- WindowHandle ---
@@ -221,6 +254,10 @@ export class WindowHandle {
     this._events.off(event, listener)
     return this
   }
+  
+  async waitFor(event: string) {
+    return this._events.waitFor(event as any)
+  }
 
   /** Register a one-time listener for a lifecycle event. */
   once<E extends keyof WindowHandleEvents>(event: E, listener: (...args: WindowHandleEvents[E]) => void): this {
@@ -282,8 +319,17 @@ interface ClientConnection {
 /**
  * WindowManager Feature — Native window control via LucaVoiceLauncher
  *
- * Acts as an IPC server that the native macOS launcher app connects to.
- * Communicates over a Unix domain socket using NDJSON (newline-delimited JSON).
+ * Uses a broker/producer architecture so multiple luca processes can trigger
+ * window operations without competing for the same Unix socket.
+ *
+ * **Architecture:**
+ * - The first process to call `listen()` becomes the **broker**. It owns
+ *   the app-facing socket (`ipc-window.sock`) and a control socket
+ *   (`ipc-window-control.sock`).
+ * - Subsequent processes detect the broker and become **producers**. They
+ *   connect to the control socket and route commands through the broker.
+ * - The broker forwards producer commands to the native app and routes
+ *   acks and lifecycle events back to the originating producer.
  *
  * **Protocol:**
  * - Bun listens on a Unix domain socket; the native app connects as a client
@@ -295,7 +341,16 @@ interface ClientConnection {
  * **Capabilities:**
  * - Spawn native browser windows with configurable chrome
  * - Navigate, focus, close, and eval JavaScript in windows
- * - Automatic socket file cleanup and fallback paths
+ * - Multiple luca processes can trigger window operations simultaneously
+ * - Automatic broker detection and producer fallback
+ *
+ * Observable state includes `windows` (open window metadata), `pendingOperations`
+ * (in-flight command ids), and `producerCount` (broker). Sockets, promises, and
+ * `WindowHandle` instances stay internal.
+ *
+ * **Producer state:** The broker pushes `windowStateSync` on the control socket when a
+ * producer connects and whenever the window roster changes, so every process sees the
+ * same `windows` / `windowCount` / `clientConnected` as the broker (not only its own acks).
  *
  * @example
  * ```typescript
@@ -321,59 +376,97 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
   static override eventsSchema = WindowManagerEventsSchema
   static { Feature.register(this, 'windowManager') }
 
-  private _server?: NetServer
-  private _client?: ClientConnection
+  // --- Shared state ---
   private _pending = new Map<string, PendingRequest>()
-  private _trackedWindows = new Set<string>()
   private _handles = new Map<string, WindowHandle>()
+  private _mode: 'broker' | 'producer' | null = null
+
+  // --- Broker-only state ---
+  private _server?: NetServer              // app-facing socket server
+  private _controlServer?: NetServer       // producer-facing socket server
+  private _client?: ClientConnection       // the connected native app
+  private _producers = new Map<string, ClientConnection>()    // connected producer processes
+  private _requestOrigins = new Map<string, Socket>()         // requestId → producer socket
+
+  // --- Producer-only state ---
+  private _controlClient?: ClientConnection  // connection to broker's control socket
 
   private normalizeRequestId(value: unknown): string | undefined {
     if (typeof value !== 'string') return undefined
     return value.toLowerCase()
   }
 
-  private waitForAnyClientConnection(timeoutMs: number, bridge?: any): Promise<'direct' | 'bridge' | undefined> {
-    if (this._client) return Promise.resolve('direct')
-    if (bridge?.isClientConnected) return Promise.resolve('bridge')
-
-    return new Promise<'direct' | 'bridge' | undefined>((resolve) => {
-      let settled = false
+  /** Lowercase map key for `_handles` so lookups match regardless of native id casing. */
+  private handleMapKey(value: unknown): string | undefined {
+    if (typeof value === 'number' && !Number.isNaN(value)) return String(value).toLowerCase()
+    return this.normalizeRequestId(value)
+  }
 
-      const cleanup = () => {
-        this.off('clientConnected', onDirectConnected)
-        bridge?.off?.('clientConnected', onBridgeConnected)
-      }
+  /**
+   * Best-effort window id from a native lifecycle message (field names differ by app version).
+   */
+  private extractLifecycleWindowId(msg: any): string | undefined {
+    if (!msg || typeof msg !== 'object') return undefined
+    const candidates = [
+      msg.windowId,
+      msg.window_id,
+      msg.windowID,
+      msg.window?.id,
+      msg.window?.windowId,
+      msg.payload?.windowId,
+      msg.result?.windowId,
+      msg.id,
+    ]
+    for (const c of candidates) {
+      if (typeof c === 'string' && c.length > 0) return c
+      if (typeof c === 'number' && !Number.isNaN(c)) return String(c)
+    }
+    return undefined
+  }
 
-      const timer = setTimeout(() => {
-        if (settled) return
-        settled = true
-        cleanup()
-        resolve(undefined)
-      }, timeoutMs)
+  /** Copy lifecycle message and set `windowId` to a canonical lowercase string when inferable. */
+  private enrichLifecycleWithCanonicalWindowId(msg: any): any {
+    const raw = this.extractLifecycleWindowId(msg)
+    if (raw === undefined) return msg
+    const key = this.handleMapKey(raw)
+    if (!key) return msg
+    return { ...msg, windowId: key }
+  }
 
-      const onDirectConnected = () => {
-        if (settled) return
-        settled = true
-        clearTimeout(timer)
-        cleanup()
-        resolve('direct')
-      }
+  /** Structured clone via JSON for stashing ack snapshots in observable state. */
+  private snapshotForState(value: unknown): any {
+    if (value === undefined) return undefined
+    try {
+      return JSON.parse(JSON.stringify(value))
+    } catch {
+      return undefined
+    }
+  }
 
-      const onBridgeConnected = () => {
-        if (settled) return
-        settled = true
-        clearTimeout(timer)
-        cleanup()
-        resolve('bridge')
-      }
+  private syncProducerCount(): void {
+    this.setState({ producerCount: this._producers.size })
+  }
 
-      this.once('clientConnected', onDirectConnected)
-      bridge?.once?.('clientConnected', onBridgeConnected)
-    })
+  private registerPendingOperation(id: string, action: string | undefined, entry: PendingRequest): void {
+    this._pending.set(id, entry)
+    this.setState((cur) => ({
+      pendingOperations: [
+        ...(cur.pendingOperations ?? []),
+        { requestId: id, action, startedAt: Date.now() },
+      ],
+    }))
   }
 
-  private getBridgeListener(): any | undefined {
-    return undefined
+  /** Clears timer, drops from `_pending` and from `pendingOperations` state. */
+  private takePendingRequest(id: string): PendingRequest | undefined {
+    const pending = this._pending.get(id)
+    if (!pending) return undefined
+    clearTimeout(pending.timer)
+    this._pending.delete(id)
+    this.setState((cur) => ({
+      pendingOperations: (cur.pendingOperations ?? []).filter((o) => o.requestId !== id),
+    }))
+    return pending
   }
 
   /** Default state: not listening, no client connected, zero windows tracked. */
@@ -383,15 +476,28 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
       listening: false,
       clientConnected: false,
       windowCount: 0,
+      windows: {},
+      pendingOperations: [],
+      producerCount: 0,
     }
   }
 
-  /** Whether the IPC server is currently listening. */
+  /** Whether this instance is acting as the broker. */
+  get isBroker(): boolean {
+    return this._mode === 'broker'
+  }
+
+  /** Whether this instance is acting as a producer. */
+  get isProducer(): boolean {
+    return this._mode === 'producer'
+  }
+
+  /** Whether the IPC server is currently listening (broker) or connected to broker (producer). */
   get isListening(): boolean {
     return this.state.get('listening') || false
   }
 
-  /** Whether the native app client is currently connected. */
+  /** Whether the native app client is currently connected (only meaningful for broker). */
   get isClientConnected(): boolean {
     return this.state.get('clientConnected') || false
   }
@@ -400,24 +506,29 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
     await super.enable(options)
 
     if (this.options.autoListen) {
-      this.listen()
+      await this.listen()
     }
 
     return this
   }
 
   /**
-   * Start listening on the Unix domain socket for the native app to connect.
-   * Fire-and-forget — binds the socket and returns immediately. Sits quietly
-   * until the native app connects; does nothing visible if it never does.
+   * Start the window manager. Automatically detects whether a broker already
+   * exists and either becomes the broker or connects as a producer.
    *
-   * @param socketPath - Override the configured socket path
+   * - If no broker is running: becomes the broker, binds the app socket and
+   *   a control socket for producers.
+   * - If a broker is already running: connects as a producer through the
+   *   control socket.
+   *
+   * @param socketPath - Override the configured app socket path
    * @returns This feature instance for chaining
    */
-  listen(socketPath?: string): this {
-    if (this._server) return this
+  async listen(socketPath?: string): Promise<this> {
+    if (this._mode) return this
 
     socketPath = socketPath || this.options.socketPath || DEFAULT_SOCKET_PATH
+    const controlPath = controlPathFor(socketPath)
 
     // Ensure the directory exists
     const dir = dirname(socketPath)
@@ -430,57 +541,80 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
       }
     }
 
-    // Clean up stale socket file
-    if (existsSync(socketPath)) {
-      try {
-        unlinkSync(socketPath)
-      } catch (error: any) {
-        this.setState({ lastError: `Failed to remove stale socket at ${socketPath}: ${error?.message || String(error)}` })
-        return this
-      }
+    // Try to connect to an existing broker's control socket
+    const brokerAlive = await this.probeSocket(controlPath)
+    if (brokerAlive) {
+      return this.connectAsProducer(controlPath, socketPath)
     }
 
-    const server = new NetServer((socket) => {
-      this.handleClientConnect(socket)
-    })
-
-    // Set immediately to prevent parallel calls from creating duplicate servers
-    this._server = server
-
-    server.on('error', (err) => {
-      this.setState({ lastError: err.message })
-    })
-
-    const finalPath = socketPath
-    server.listen(finalPath, () => {
-      this.setState({ listening: true, socketPath: finalPath })
-      this.emit('listening')
-    })
+    // No broker — we become the broker
+    return this.becomeBroker(socketPath, controlPath)
+  }
 
-    return this
+  /**
+   * Remove stale socket files without starting or stopping the server.
+   * Useful when a previous process crashed and left dead sockets behind.
+   * Will not remove sockets that have live listeners.
+   *
+   * @param socketPath - Override the configured socket path
+   * @returns true if a stale socket was removed
+   */
+  async cleanupSocket(socketPath?: string): Promise<boolean> {
+    socketPath = socketPath || this.options.socketPath || DEFAULT_SOCKET_PATH
+    if (this._server) return false
+    if (!existsSync(socketPath)) return false
+    const isAlive = await this.probeSocket(socketPath)
+    if (isAlive) return false
+    try {
+      unlinkSync(socketPath)
+      return true
+    } catch {
+      return false
+    }
   }
 
   /**
-   * Stop the IPC server and clean up all connections.
+   * Stop the window manager and clean up all connections.
    * Rejects any pending window operation requests.
    *
    * @returns This feature instance for chaining
    */
   async stop(): Promise<this> {
+    // Resolve all pending requests
     for (const [, pending] of this._pending) {
       clearTimeout(pending.timer)
       pending.resolve({ ok: false, error: 'Server stopping' })
     }
     this._pending.clear()
-    this._trackedWindows.clear()
     this._handles.clear()
 
+    // --- Producer cleanup ---
+    if (this._controlClient) {
+      this._controlClient.socket.destroy()
+      this._controlClient = undefined
+    }
+
+    // --- Broker cleanup ---
     if (this._client) {
       this._client.socket.destroy()
       this._client = undefined
     }
 
+    for (const [, producer] of this._producers) {
+      producer.socket.destroy()
+    }
+    this._producers.clear()
+    this._requestOrigins.clear()
+
     const socketPath = this.state.get('socketPath')
+    const controlPath = socketPath ? controlPathFor(socketPath) : undefined
+
+    if (this._controlServer) {
+      await new Promise<void>((resolve) => {
+        this._controlServer!.close(() => resolve())
+      })
+      this._controlServer = undefined
+    }
 
     if (this._server) {
       await new Promise<void>((resolve) => {
@@ -489,12 +623,27 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
       this._server = undefined
     }
 
-    // Clean up the socket file
-    if (socketPath && existsSync(socketPath)) {
-      try { unlinkSync(socketPath) } catch { /* ignore */ }
+    // Clean up socket files (only if we were the broker)
+    if (this._mode === 'broker') {
+      if (socketPath && existsSync(socketPath)) {
+        try { unlinkSync(socketPath) } catch { /* ignore */ }
+      }
+      if (controlPath && existsSync(controlPath)) {
+        try { unlinkSync(controlPath) } catch { /* ignore */ }
+      }
     }
 
-    this.setState({ listening: false, clientConnected: false, socketPath: undefined, windowCount: 0 })
+    this._mode = null
+    this.setState({
+      listening: false,
+      clientConnected: false,
+      socketPath: undefined,
+      windowCount: 0,
+      windows: {},
+      pendingOperations: [],
+      producerCount: 0,
+      mode: undefined,
+    })
     return this
   }
 
@@ -528,7 +677,7 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
       })
     }
 
-    return this.getOrCreateHandle(ackResult.windowId, ackResult)
+    return this.getOrCreateHandle(ackResult.windowId, ackResult, 'browser')
   }
 
   /**
@@ -557,7 +706,7 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
       })
     }
 
-    return this.getOrCreateHandle(ackResult.windowId, ackResult)
+    return this.getOrCreateHandle(ackResult.windowId, ackResult, 'terminal')
   }
 
   /**
@@ -712,68 +861,132 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
     return results
   }
 
+  /**
+   * Write an NDJSON message to the connected app client.
+   * In producer mode, routes through the broker.
+   * Public so other features can send arbitrary protocol messages over the same socket.
+   *
+   * @param msg - The message object to send (will be JSON-serialized + newline)
+   * @returns True if the message was written, false if no connection is available
+   */
+  send(msg: Record<string, any>): boolean {
+    if (this._mode === 'producer' && this._controlClient) {
+      this._controlClient.socket.write(JSON.stringify(msg) + '\n')
+      return true
+    }
+    if (!this._client) return false
+    this._client.socket.write(JSON.stringify(msg) + '\n')
+    return true
+  }
+
+  // =====================================================================
+  // Private — Broker / Producer lifecycle
+  // =====================================================================
+
   /** Get or create a tracked WindowHandle for a given windowId. */
-  private getOrCreateHandle(windowId: string | undefined, result?: WindowAckResult): WindowHandle {
-    const id = windowId || randomUUID()
-    let handle = this._handles.get(id)
+  private getOrCreateHandle(
+    windowId: string | undefined,
+    result?: WindowAckResult,
+    kind: 'browser' | 'terminal' | 'unknown' = 'unknown',
+  ): WindowHandle {
+    const id = windowId ?? result?.windowId ?? randomUUID()
+    const mapKey = this.handleMapKey(id) ?? id
+    let handle = this._handles.get(mapKey)
     if (!handle) {
       handle = new WindowHandle(id, this, result)
-      this._handles.set(id, handle)
+      this._handles.set(mapKey, handle)
     } else if (result) {
       handle.result = result
     }
+    this.trackWindowOpened(id, { kind: kind !== 'unknown' ? kind : undefined })
     return handle
   }
 
-  // --- Private internals ---
-
-  private _displayCache: { width: number; height: number } | null = null
-
   /**
-   * Get the primary display resolution, cached for the lifetime of the feature.
+   * Probe an existing socket to see if a live listener is behind it.
+   * Attempts a quick connect — if it succeeds, someone is listening.
    */
-  private getPrimaryDisplay(): { width: number; height: number } {
-    if (this._displayCache) return this._displayCache
-    const osFeature = this.container.feature('os')
-    const displays = osFeature.getDisplayInfo()
-    const primary = displays.find(d => d.main) ?? displays[0]
-    if (!primary) throw new Error('No displays found')
-    this._displayCache = { width: primary.resolution.width, height: primary.resolution.height }
-    return this._displayCache
-  }
+  private probeSocket(socketPath: string): Promise<boolean> {
+    if (!existsSync(socketPath)) return Promise.resolve(false)
+    return new Promise<boolean>((resolve) => {
+      const probe = new Socket()
+      const timer = setTimeout(() => {
+        probe.destroy()
+        resolve(false)
+      }, 500)
 
-  /**
-   * Resolve percentage-based dimension values to absolute points using the primary display.
-   * Passes through absolute numbers unchanged. Only fetches display info if percentages are present.
-   */
-  private resolveDimensions<T extends Record<string, any>>(opts: T): T {
-    const keys = ['width', 'height', 'x', 'y'] as const
-    const hasPercentage = keys.some(k => typeof opts[k] === 'string' && (opts[k] as string).endsWith('%'))
-    if (!hasPercentage) return opts
+      probe.once('connect', () => {
+        clearTimeout(timer)
+        probe.destroy()
+        resolve(true)
+      })
 
-    const display = this.getPrimaryDisplay()
-    const resolved = { ...opts }
+      probe.once('error', () => {
+        clearTimeout(timer)
+        probe.destroy()
+        resolve(false)
+      })
 
-    for (const key of keys) {
-      const val = opts[key]
-      if (typeof val === 'string' && val.endsWith('%')) {
-        const pct = parseFloat(val) / 100
-        const ref = (key === 'width' || key === 'x') ? display.width : display.height
-        ;(resolved as any)[key] = Math.round(pct * ref)
-      }
+      probe.connect(socketPath)
+    })
+  }
+
+  // =====================================================================
+  // Broker mode — owns the app socket and the control socket
+  // =====================================================================
+
+  private async becomeBroker(socketPath: string, controlPath: string): Promise<this> {
+    // Clean up stale app socket
+    if (existsSync(socketPath)) {
+      try { unlinkSync(socketPath) } catch { /* ignore */ }
+    }
+    // Clean up stale control socket
+    if (existsSync(controlPath)) {
+      try { unlinkSync(controlPath) } catch { /* ignore */ }
     }
 
-    return resolved
+    // Bind the app-facing socket (native launcher connects here)
+    const server = new NetServer((socket) => {
+      this.handleAppClientConnect(socket)
+    })
+    this._server = server
+
+    server.on('error', (err) => {
+      this.setState({ lastError: err.message })
+    })
+
+    await new Promise<void>((resolve) => {
+      server.listen(socketPath, () => resolve())
+    })
+
+    // Bind the control socket (producer processes connect here)
+    const controlServer = new NetServer((socket) => {
+      this.handleProducerConnect(socket)
+    })
+    this._controlServer = controlServer
+
+    controlServer.on('error', (err) => {
+      this.setState({ lastError: `Control socket error: ${err.message}` })
+    })
+
+    await new Promise<void>((resolve) => {
+      controlServer.listen(controlPath, () => resolve())
+    })
+
+    this._mode = 'broker'
+    this.setState({ listening: true, socketPath, mode: 'broker' })
+    this.emit('listening')
+
+    return this
   }
 
   /**
-   * Handle a new client connection from the native app.
+   * Handle a new app client connection from the native launcher.
    * Sets up NDJSON buffering and event forwarding.
    */
-  private handleClientConnect(socket: Socket): void {
+  private handleAppClientConnect(socket: Socket): void {
     const client: ClientConnection = { socket, buffer: '' }
 
-    // Replace any existing client (single-client model)
     if (this._client) {
       this._client.socket.destroy()
     }
@@ -787,24 +1000,42 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
       const lines = client.buffer.split('\n')
       client.buffer = lines.pop() || ''
       for (const line of lines) {
-        if (line.trim()) this.processLine(line)
+        if (line.trim()) this.processAppMessage(line)
       }
     })
 
     socket.on('close', () => {
       if (this._client === client) {
         this._client = undefined
-        this._trackedWindows.clear()
         this._handles.clear()
-        this.setState({ clientConnected: false, windowCount: 0 })
-
-        // Resolve all pending requests — the app is gone, no acks coming
-        for (const [id, pending] of this._pending) {
+        this.setState({
+          clientConnected: false,
+          windowCount: 0,
+          windows: {},
+          pendingOperations: [],
+        })
+        this.broadcastWindowStateSync()
+
+        // Resolve all pending requests — the app is gone
+        for (const [, pending] of this._pending) {
           clearTimeout(pending.timer)
           pending.resolve({ ok: false, error: 'Client disconnected' })
         }
         this._pending.clear()
 
+        // Notify producers that app disconnected — resolve their in-flight requests
+        for (const [reqId, producerSocket] of this._requestOrigins) {
+          try {
+            producerSocket.write(JSON.stringify({
+              type: 'windowAck',
+              id: reqId,
+              success: false,
+              error: 'App client disconnected',
+            }) + '\n')
+          } catch { /* producer gone */ }
+        }
+        this._requestOrigins.clear()
+
         this.emit('clientDisconnected')
       }
     })
@@ -815,149 +1046,431 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
   }
 
   /**
-   * Process a single complete NDJSON line from the app.
-   * Resolves pending windowAck requests; emits `message` for everything else.
+   * Handle a new producer connection on the control socket.
+   * Producers send window commands; broker forwards to app and routes acks back.
+   */
+  private handleProducerConnect(socket: Socket): void {
+    const id = randomUUID()
+    const client: ClientConnection = { socket, buffer: '' }
+    this._producers.set(id, client)
+    this.syncProducerCount()
+    this.sendWindowStateSyncToSocket(socket)
+
+    socket.on('data', (chunk) => {
+      client.buffer += chunk.toString()
+      const lines = client.buffer.split('\n')
+      client.buffer = lines.pop() || ''
+      for (const line of lines) {
+        if (line.trim()) this.processProducerMessage(line, socket)
+      }
+    })
+
+    socket.on('close', () => {
+      this._producers.delete(id)
+      this.syncProducerCount()
+      // Clean up request origins for this producer
+      for (const [reqId, sock] of this._requestOrigins) {
+        if (sock === socket) this._requestOrigins.delete(reqId)
+      }
+    })
+
+    socket.on('error', () => {
+      this._producers.delete(id)
+      this.syncProducerCount()
+    })
+  }
+
+  /**
+   * Process a message from a producer. Records the origin so acks can be
+   * routed back, then forwards the command to the app client.
    */
-  private processLine(line: string): void {
+  private processProducerMessage(line: string, producerSocket: Socket): void {
     let msg: any
-    try {
-      msg = JSON.parse(line)
-    } catch {
-      return // Malformed JSON ignored per spec
+    try { msg = JSON.parse(line) } catch { return }
+
+    const requestId = this.normalizeRequestId(msg.id)
+    if (requestId) {
+      this._requestOrigins.set(requestId, producerSocket)
     }
 
-    // WindowAck from app (response to a window dispatch)
+    // Forward to the native app client
+    if (!this._client) {
+      // No app connected — send error back to producer immediately
+      if (requestId) {
+        this._requestOrigins.delete(requestId)
+        try {
+          producerSocket.write(JSON.stringify({
+            type: 'windowAck',
+            id: msg.id,
+            success: false,
+            error: 'No native launcher client connected',
+          }) + '\n')
+        } catch { /* producer gone */ }
+      }
+      return
+    }
+
+    this._client.socket.write(line + '\n')
+  }
+
+  /**
+   * Process a message from the native app (broker mode).
+   * Routes windowAck back to the originating producer or resolves locally.
+   * Broadcasts lifecycle events to all producers.
+   */
+  private processAppMessage(line: string): void {
+    let msg: any
+    try { msg = JSON.parse(line) } catch { return }
+
     if (msg.type === 'windowAck') {
       this.emit('windowAck', msg)
-      this.updateTrackedWindowsFromAck(msg)
+      const rosterChanged = this.updateTrackedWindowsFromAck(msg)
 
       const ackId = this.normalizeRequestId(msg.id)
-      if (ackId && this._pending.has(ackId)) {
-        const pending = this._pending.get(ackId)!
-        this._pending.delete(ackId)
-        clearTimeout(pending.timer)
-
-        if (msg.success) {
-          pending.resolve(msg.result ?? msg)
-        } else {
-          pending.resolve({ ok: false, error: msg.error || 'Window operation failed' })
+
+      // Route to originating producer if this was a proxied request
+      if (ackId && this._requestOrigins.has(ackId)) {
+        const producerSocket = this._requestOrigins.get(ackId)!
+        this._requestOrigins.delete(ackId)
+        try {
+          producerSocket.write(line + '\n')
+        } catch { /* producer disconnected */ }
+        if (rosterChanged) this.broadcastWindowStateSync()
+        return
+      }
+
+      // Otherwise resolve locally (broker's own request)
+      if (ackId) {
+        const pending = this.takePendingRequest(ackId)
+        if (pending) {
+          if (msg.success) {
+            pending.resolve(msg.result ?? msg)
+          } else {
+            pending.resolve({ ok: false, error: msg.error || 'Window operation failed' })
+          }
         }
       }
+      if (rosterChanged) this.broadcastWindowStateSync()
       return
     }
 
+    let messageOut = msg
+
     if (msg.type === 'windowClosed') {
-      this.trackWindowClosed(msg.windowId)
-      const handle = this._handles.get(msg.windowId)
-      if (handle) {
-        handle.emit('close', msg)
-        this._handles.delete(msg.windowId)
+      messageOut = this.enrichLifecycleWithCanonicalWindowId(msg)
+      this.trackWindowClosed(messageOut.windowId)
+      const key = this.handleMapKey(messageOut.windowId)
+      const handle = key ? this._handles.get(key) : undefined
+      if (handle && key) {
+        handle.emit('close', messageOut)
+        this._handles.delete(key)
       }
-      this.emit('windowClosed', msg)
+      this.emit('windowClosed', messageOut)
+      // Broadcast to all producers
+      this.broadcastToProducers(JSON.stringify(messageOut))
+      this.broadcastWindowStateSync()
     }
 
     if (msg.type === 'terminalExited') {
-      const handle = msg.windowId ? this._handles.get(msg.windowId) : undefined
-      if (handle) handle.emit('terminalExited', msg)
-      this.emit('terminalExited', msg)
+      messageOut = this.enrichLifecycleWithCanonicalWindowId(msg)
+      const key = this.handleMapKey(messageOut.windowId)
+      const handle = key ? this._handles.get(key) : undefined
+      if (handle) handle.emit('terminalExited', messageOut)
+      this.emit('terminalExited', messageOut)
+      // Broadcast to all producers
+      this.broadcastToProducers(JSON.stringify(messageOut))
     }
 
-    // Everything else is forwarded as a generic message
-    this.emit('message', msg)
+    if (msg.type === 'windowFocus') {
+      messageOut = this.enrichLifecycleWithCanonicalWindowId(msg)
+      const key = this.handleMapKey(messageOut.windowId)
+      const handle = key ? this._handles.get(key) : undefined
+      if (handle) handle.emit(messageOut.focused ? 'focus' : 'blur', messageOut)
+      this.emit('windowFocus', messageOut)
+      // Broadcast to all producers
+      this.broadcastToProducers(JSON.stringify(messageOut))
+    }
+
+    this.emit('message', messageOut)
   }
 
-  private updateTrackedWindowsFromAck(msg: any): void {
-    if (!msg?.success) return
-    if (typeof msg?.action !== 'string') return
+  /** Send an NDJSON line to all connected producers. */
+  private broadcastToProducers(line: string): void {
+    for (const [, producer] of this._producers) {
+      try {
+        producer.socket.write(line + '\n')
+      } catch { /* producer gone */ }
+    }
+  }
 
-    const action = msg.action.toLowerCase()
-    const resultWindowId = msg?.result?.windowId
+  /** Broker: snapshot of roster + app connectivity for producers (internal protocol). */
+  private buildWindowStateSyncPayload(): Record<string, unknown> {
+    return {
+      type: 'windowStateSync',
+      windows: this.state.get('windows') ?? {},
+      windowCount: this.state.get('windowCount') ?? 0,
+      clientConnected: this.state.get('clientConnected') ?? false,
+    }
+  }
 
-    if (action === 'open' || action === 'spawn' || action === 'terminal') {
-      this.trackWindowOpened(resultWindowId)
+  /** Broker: push current window roster to one producer control socket. */
+  private sendWindowStateSyncToSocket(socket: Socket): void {
+    if (this._mode !== 'broker') return
+    try {
+      socket.write(JSON.stringify(this.buildWindowStateSyncPayload()) + '\n')
+    } catch { /* gone */ }
+  }
+
+  /** Broker: fan out roster snapshot so all producers converge with broker state. */
+  private broadcastWindowStateSync(): void {
+    if (this._mode !== 'broker' || this._producers.size === 0) return
+    const line = JSON.stringify(this.buildWindowStateSyncPayload())
+    this.broadcastToProducers(line)
+  }
+
+  // =====================================================================
+  // Producer mode — routes commands through the broker
+  // =====================================================================
+
+  private connectAsProducer(controlPath: string, socketPath: string): Promise<this> {
+    return new Promise<this>((resolve, reject) => {
+      const socket = new Socket()
+      const client: ClientConnection = { socket, buffer: '' }
+
+      const timer = setTimeout(() => {
+        socket.destroy()
+        this.setState({ lastError: `Timed out connecting to broker at ${controlPath}` })
+        reject(new WindowManagerError(`Timed out connecting to broker`, 'Timeout'))
+      }, 3000)
+
+      socket.connect(controlPath, () => {
+        clearTimeout(timer)
+        this._mode = 'producer'
+        this._controlClient = client
+        this.setState({ listening: true, socketPath, mode: 'producer' })
+        this.emit('listening')
+        resolve(this)
+      })
+
+      socket.on('data', (chunk) => {
+        client.buffer += chunk.toString()
+        const lines = client.buffer.split('\n')
+        client.buffer = lines.pop() || ''
+        for (const line of lines) {
+          if (line.trim()) this.processProducerIncoming(line)
+        }
+      })
+
+      socket.on('close', () => {
+        this._controlClient = undefined
+        this._mode = null
+        for (const [mapKey, handle] of [...this._handles.entries()]) {
+          handle.emit('close', {
+            type: 'windowClosed',
+            windowId: mapKey,
+            reason: 'brokerDisconnected',
+          })
+        }
+        this._handles.clear()
+        this.setState({
+          listening: false,
+          mode: undefined,
+          pendingOperations: [],
+          windows: {},
+          windowCount: 0,
+        })
+
+        // Resolve all pending requests — broker is gone
+        for (const [, pending] of this._pending) {
+          clearTimeout(pending.timer)
+          pending.resolve({ ok: false, error: 'Broker disconnected' })
+        }
+        this._pending.clear()
+      })
+
+      socket.on('error', (err) => {
+        clearTimeout(timer)
+        this.setState({ lastError: `Broker connection error: ${err.message}` })
+      })
+    })
+  }
+
+  /**
+   * Process a message received from the broker (producer mode).
+   * Handles windowAck (resolves pending requests) and lifecycle events.
+   */
+  private processProducerIncoming(line: string): void {
+    let msg: any
+    try { msg = JSON.parse(line) } catch { return }
+
+    if (msg.type === 'windowStateSync') {
+      this.applyProducerWindowStateSync(msg)
       return
     }
 
-    if (action === 'close') {
-      this.trackWindowClosed(resultWindowId)
+    if (msg.type === 'windowAck') {
+      this.emit('windowAck', msg)
+      this.updateTrackedWindowsFromAck(msg)
+
+      const ackId = this.normalizeRequestId(msg.id)
+      if (ackId) {
+        const pending = this.takePendingRequest(ackId)
+        if (pending) {
+          if (msg.success) {
+            pending.resolve(msg.result ?? msg)
+          } else {
+            pending.resolve({ ok: false, error: msg.error || 'Window operation failed' })
+          }
+        }
+      }
+      return
+    }
+
+    let messageOut = msg
+
+    if (msg.type === 'windowClosed') {
+      messageOut = this.enrichLifecycleWithCanonicalWindowId(msg)
+      this.trackWindowClosed(messageOut.windowId)
+      const key = this.handleMapKey(messageOut.windowId)
+      const handle = key ? this._handles.get(key) : undefined
+      if (handle && key) {
+        handle.emit('close', messageOut)
+        this._handles.delete(key)
+      }
+      this.emit('windowClosed', messageOut)
+    }
+
+    if (msg.type === 'terminalExited') {
+      messageOut = this.enrichLifecycleWithCanonicalWindowId(msg)
+      const key = this.handleMapKey(messageOut.windowId)
+      const handle = key ? this._handles.get(key) : undefined
+      if (handle) handle.emit('terminalExited', messageOut)
+      this.emit('terminalExited', messageOut)
+    }
+
+    if (msg.type === 'windowFocus') {
+      messageOut = this.enrichLifecycleWithCanonicalWindowId(msg)
+      const key = this.handleMapKey(messageOut.windowId)
+      const handle = key ? this._handles.get(key) : undefined
+      if (handle) handle.emit(messageOut.focused ? 'focus' : 'blur', messageOut)
+      this.emit('windowFocus', messageOut)
     }
+
+    this.emit('message', messageOut)
   }
 
-  private trackWindowOpened(windowId: unknown): void {
-    const normalized = this.normalizeRequestId(windowId)
-    if (!normalized) return
-    this._trackedWindows.add(normalized)
-    this.setState({ windowCount: this._trackedWindows.size })
+  // =====================================================================
+  // Shared internals
+  // =====================================================================
+
+  private _displayCache: { width: number; height: number } | null = null
+
+  /**
+   * Get the primary display resolution, cached for the lifetime of the feature.
+   */
+  private getPrimaryDisplay(): { width: number; height: number } {
+    if (this._displayCache) return this._displayCache
+    const osFeature = this.container.feature('os')
+    const displays = osFeature.getDisplayInfo()
+    const primary = displays.find(d => d.main) ?? displays[0]
+    if (!primary) throw new Error('No displays found')
+    this._displayCache = { width: primary.resolution.width, height: primary.resolution.height }
+    return this._displayCache
   }
 
-  private trackWindowClosed(windowId: unknown): void {
-    const normalized = this.normalizeRequestId(windowId)
-    if (!normalized) return
-    this._trackedWindows.delete(normalized)
-    this.setState({ windowCount: this._trackedWindows.size })
+  /**
+   * Resolve percentage-based dimension values to absolute points using the primary display.
+   * Passes through absolute numbers unchanged. Only fetches display info if percentages are present.
+   */
+  private resolveDimensions<T extends Record<string, any>>(opts: T): T {
+    const keys = ['width', 'height', 'x', 'y'] as const
+    const hasPercentage = keys.some(k => typeof opts[k] === 'string' && (opts[k] as string).endsWith('%'))
+    if (!hasPercentage) return opts
+
+    const display = this.getPrimaryDisplay()
+    const resolved = { ...opts }
+
+    for (const key of keys) {
+      const val = opts[key]
+      if (typeof val === 'string' && val.endsWith('%')) {
+        const pct = parseFloat(val) / 100
+        const ref = (key === 'width' || key === 'x') ? display.width : display.height
+        ;(resolved as any)[key] = Math.round(pct * ref)
+      }
+    }
+
+    return resolved
   }
 
   /**
-   * Send a window dispatch command to the app and wait for the ack.
-   * Generates a UUID for correlation and sets up a timeout.
+   * Send a window dispatch command and wait for the ack.
+   * In broker mode, sends directly to the app client.
+   * In producer mode, routes through the broker via the control socket.
+   * If not yet started, calls listen() to auto-detect mode.
    */
   private sendWindowCommand(windowPayload: Record<string, any>): Promise<WindowAckResult> {
     return new Promise<WindowAckResult>(async (resolve, reject) => {
       const timeoutMs = this.options.requestTimeoutMs || 10000
-      const bridge = this.getBridgeListener()
 
-      // If the command-listener already owns the socket, bridge through it instead
-      // of binding a competing server on the same path.
-      if (!this._server && !bridge?.isListening) {
-        this.listen()
+      // Auto-start if needed
+      if (!this._mode) {
+        await this.listen()
       }
 
-      const connectionMode = await this.waitForAnyClientConnection(timeoutMs, bridge)
-      if (!connectionMode) {
-        const error = `No native launcher client connected on socket ${this.state.get('socketPath') || this.options.socketPath}`
-        this.setState({ lastError: error })
-        resolve({ ok: false, error, code: 'NoClient' })
-        return
-      }
+      // In producer mode, we don't wait for app client — the broker handles that.
+      // We just need our control connection to be alive.
+      if (this._mode === 'producer') {
+        if (!this._controlClient) {
+          resolve({ ok: false, error: 'Not connected to broker', code: 'Disconnected' })
+          return
+        }
 
-      const rawId = randomUUID()
-      const id = this.normalizeRequestId(rawId) || rawId
-      const usingBridge = connectionMode === 'bridge'
+        const rawId = randomUUID()
+        const id = this.normalizeRequestId(rawId) || rawId
 
-      let bridgeMessageListener: ((msg: any) => void) | undefined
-      const cleanupBridgeListener = () => {
-        if (usingBridge && bridgeMessageListener) {
-          bridge.off?.('message', bridgeMessageListener)
-          bridgeMessageListener = undefined
-        }
-      }
+        const timer = setTimeout(() => {
+          const p = this.takePendingRequest(id)
+          if (p) {
+            p.resolve({ ok: false, error: `Window ${windowPayload.action} timed out after ${timeoutMs}ms`, code: 'Timeout' })
+          }
+        }, timeoutMs)
+
+        this.registerPendingOperation(id, windowPayload.action, { resolve, reject, timer })
 
-      if (usingBridge) {
-        bridgeMessageListener = (msg: any) => {
-          if (!msg || msg.type !== 'windowAck') return
-          const ackId = this.normalizeRequestId(msg.id)
-          if (ackId !== id) return
-          this.processLine(JSON.stringify(msg))
+        const payload = {
+          id,
+          status: 'processing',
+          window: windowPayload,
+          timestamp: new Date().toISOString(),
         }
-        bridge.on?.('message', bridgeMessageListener)
-      }
 
-      const completeResolve = (value: any) => {
-        cleanupBridgeListener()
-        resolve(value)
+        this._controlClient.socket.write(JSON.stringify(payload) + '\n')
+        return
       }
 
-      const completeReject = (reason: any) => {
-        cleanupBridgeListener()
-        reject(reason)
+      // Broker mode — send directly to app client
+      if (!this._client) {
+        // Wait for app client to connect
+        const connected = await this.waitForAppClient(timeoutMs)
+        if (!connected) {
+          const error = `No native launcher client connected on socket ${this.state.get('socketPath') || this.options.socketPath}`
+          this.setState({ lastError: error })
+          resolve({ ok: false, error, code: 'NoClient' })
+          return
+        }
       }
 
+      const rawId = randomUUID()
+      const id = this.normalizeRequestId(rawId) || rawId
+
       const timer = setTimeout(() => {
-        this._pending.delete(id)
-        completeResolve({ ok: false, error: `Window ${windowPayload.action} timed out after ${timeoutMs}ms`, code: 'Timeout' })
+        const p = this.takePendingRequest(id)
+        if (p) {
+          p.resolve({ ok: false, error: `Window ${windowPayload.action} timed out after ${timeoutMs}ms`, code: 'Timeout' })
+        }
       }, timeoutMs)
 
-      this._pending.set(id, { resolve: completeResolve, reject: completeReject, timer })
+      this.registerPendingOperation(id, windowPayload.action, { resolve, reject, timer })
 
       const payload = {
         id,
@@ -965,30 +1478,125 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
         window: windowPayload,
         timestamp: new Date().toISOString(),
       }
-      const sent = usingBridge ? bridge.send(payload) : this.send(payload)
+      const sent = this.send(payload)
 
       if (!sent) {
-        clearTimeout(timer)
-        this._pending.delete(id)
-        cleanupBridgeListener()
+        const p = this.takePendingRequest(id)
         const error = `Failed to send window ${windowPayload.action}: client disconnected`
         this.setState({ lastError: error })
-        resolve({ ok: false, error, code: 'Disconnected' })
+        if (p) {
+          p.resolve({ ok: false, error, code: 'Disconnected' })
+        }
       }
     })
   }
 
-  /**
-   * Write an NDJSON message to the connected app client.
-   * Public so other features can send arbitrary protocol messages over the same socket.
-   *
-   * @param msg - The message object to send (will be JSON-serialized + newline)
-   * @returns True if the message was written, false if no client is connected
-   */
-  send(msg: Record<string, any>): boolean {
-    if (!this._client) return false
-    this._client.socket.write(JSON.stringify(msg) + '\n')
-    return true
+  /** Wait for the native app to connect (broker mode only). */
+  private waitForAppClient(timeoutMs: number): Promise<boolean> {
+    if (this._client) return Promise.resolve(true)
+
+    return new Promise<boolean>((resolve) => {
+      const timer = setTimeout(() => {
+        this.off('clientConnected', onConnected)
+        resolve(false)
+      }, timeoutMs)
+
+      const onConnected = () => {
+        clearTimeout(timer)
+        resolve(true)
+      }
+
+      this.once('clientConnected', onConnected)
+    })
+  }
+
+  /** Returns true if the open-window roster changed (broker should fan out `windowStateSync`). */
+  private updateTrackedWindowsFromAck(msg: any): boolean {
+    if (!msg?.success) return false
+    if (typeof msg?.action !== 'string') return false
+
+    const action = msg.action.toLowerCase()
+    const resultWindowId = msg?.result?.windowId
+
+    if (action === 'open' || action === 'spawn' || action === 'terminal') {
+      const before = Object.keys(this.state.get('windows') ?? {}).length
+      this.trackWindowOpened(resultWindowId, {
+        kind: action === 'terminal' ? 'terminal' : 'browser',
+        lastAck: msg,
+      })
+      return Object.keys(this.state.get('windows') ?? {}).length !== before
+    }
+
+    if (action === 'close') {
+      const before = Object.keys(this.state.get('windows') ?? {}).length
+      this.trackWindowClosed(resultWindowId)
+      return Object.keys(this.state.get('windows') ?? {}).length !== before
+    }
+
+    return false
+  }
+
+  /** Producer: apply broker snapshot; drop local handles for windows no longer in the roster. */
+  private applyProducerWindowStateSync(msg: any): void {
+    const raw = msg?.windows
+    const windows =
+      raw && typeof raw === 'object' && !Array.isArray(raw)
+        ? (raw as Record<string, WindowTrackedEntry>)
+        : {}
+    const windowCount =
+      typeof msg?.windowCount === 'number' ? msg.windowCount : Object.keys(windows).length
+    const patch: Partial<WindowManagerState> = { windows, windowCount }
+    if (typeof msg?.clientConnected === 'boolean') {
+      patch.clientConnected = msg.clientConnected
+    }
+    this.setState(patch)
+    this.pruneHandlesMissingFromRoster(windows)
+  }
+
+  private pruneHandlesMissingFromRoster(windows: Record<string, WindowTrackedEntry>): void {
+    const allowed = new Set(Object.keys(windows))
+    for (const [mapKey, handle] of [...this._handles.entries()]) {
+      if (!allowed.has(mapKey)) {
+        handle.emit('close', {
+          type: 'windowClosed',
+          windowId: mapKey,
+          reason: 'windowStateSync',
+        })
+        this._handles.delete(mapKey)
+      }
+    }
+  }
+
+  private trackWindowOpened(
+    windowId: unknown,
+    extra?: { kind?: 'browser' | 'terminal' | 'unknown'; lastAck?: unknown },
+  ): void {
+    const normalized = this.normalizeRequestId(windowId)
+    if (!normalized) return
+    const native = typeof windowId === 'string' ? windowId : normalized
+    this.setState((cur) => {
+      const windows = { ...(cur.windows ?? {}) }
+      const prev = windows[normalized]
+      windows[normalized] = {
+        windowId: normalized,
+        nativeWindowId: prev?.nativeWindowId ?? native,
+        openedAt: prev?.openedAt ?? Date.now(),
+        lastAck:
+          extra?.lastAck !== undefined ? this.snapshotForState(extra.lastAck) : prev?.lastAck,
+        kind: extra?.kind ?? prev?.kind ?? 'unknown',
+      }
+      return { windows, windowCount: Object.keys(windows).length }
+    })
+  }
+
+  private trackWindowClosed(windowId: unknown): void {
+    const normalized = this.normalizeRequestId(windowId)
+    if (!normalized) return
+    this.setState((cur) => {
+      const windows = { ...(cur.windows ?? {}) }
+      delete windows[normalized]
+      return { windows, windowCount: Object.keys(windows).length }
+    })
   }
 }