@tryinget/pi-activity-strip 0.8.0 → 0.10.0

package/src/native/panel-projection.mjs

@@ -3,23 +3,39 @@
 // read_when:
 //   - "changing native panel card membership, focus, or transport revisions"
 // ---
-
 import { joinAkTaskChips } from "../common/ak-tasks.mjs";
 import { resolveSnapshotSession } from "../common/niri-focus.mjs";
 import { projectSessionCards, sessionRecordKey } from "../common/session-cards.mjs";
+import { classifyAdmittedWindowFocus } from "../common/workspace-view.mjs";
+import { createFocusVisibility } from "./focus-visibility.mjs";
+import {
+  agentSourceMatches,
+  publisherSet,
+  selectionContradictsSource,
+  sourceIdentity,
+  visibleCardsForWindow,
+} from "./interaction-context.mjs";
+import { createNeutralSource } from "./panel-neutral-source.mjs";
+import { createPanelPresentation } from "./panel-presentation.mjs";
+import { PANEL_PROTOCOL } from "./panel-protocol.mjs";
 
 /** @typedef {Record<string, unknown>} SessionRecord */
 /** @typedef {{generatedAt: number; sessions: SessionRecord[]}} Snapshot */
-/** @typedef {{workspace: Record<string, unknown> | null; sessions: SessionRecord[]; focusedSessionId: string | null; focusedCardId?: string | null}} WorkspaceView */
+/** @typedef {{workspace: Record<string, unknown> | null; sessions: SessionRecord[]; focusedSessionId: string | null; focusedCardId?: string | null; focusWindowId?: number | null; focusKind?: import("./focus-visibility.mjs").FocusKind}} WorkspaceView */
 /** @typedef {{placement: string; surfaceVisible: boolean; windowId: number | null; workspaceIdx: number | null}} CardPlacement */
-/** @typedef {{isNiriSession: () => boolean; publish: (view: Record<string, unknown> & {type: string; sessions: SessionRecord[]}) => void}} NativePanelProjectionOptions */
+/** @typedef {{isNiriSession: () => boolean; publish: (view: Record<string, unknown> & {type: string; sessions: SessionRecord[]}) => void; getWindowFacts?: (id: number) => Record<string, unknown> | null; env?: NodeJS.ProcessEnv; hotkey?: string | null}} NativePanelProjectionOptions */
 
 /** @param {NativePanelProjectionOptions} options */
-export function createNativePanelProjection({ isNiriSession, publish }) {
+export function createNativePanelProjection({
+  isNiriSession,
+  publish,
+  getWindowFacts = () => null,
+  env = process.env,
+  hotkey = null,
+}) {
   /** @type {Snapshot} */
   let snapshot = { generatedAt: Date.now(), sessions: [] };
-  /** Agent tabs discovered from the process table; they publish no telemetry of their own. */
-  /** @type {SessionRecord[]} */
+  /** Process-discovered agent tabs publish no telemetry. @type {SessionRecord[]} */
   let agentSessions = [];
   /** @type {string | null} */
   let focusedSessionId = null;
@@ -33,10 +49,79 @@ export function createNativePanelProjection({ isNiriSession, publish }) {
   let workspaceRecordKeys = new Set();
   /** @type {Map<string, CardPlacement>} */
   let workspacePlacements = new Map();
-  /** Read-only AK task claims joined onto cards; absent until the first successful AK read. */
-  /** @type {{claims: import("../common/contracts.ts").AkTaskClaim[]; deferred: import("../common/contracts.ts").AkTaskDeferred[]} | null} */
+  /** Read-only AK data; absent until first read. @type {{claims: import("../common/contracts.ts").AkTaskClaim[]; deferred: import("../common/contracts.ts").AkTaskDeferred[]} | null} */
   let akTasks = null;
+  /** All-workspace window list. @type {import("../common/workspace-view.mjs").WindowDirectoryEntry[]} */
+  let directory = [];
+  /** @type {Map<string, SessionRecord>} */
+  let directoryCards = new Map();
   let revision = 0;
+  let nextKeyboardRequest = 0;
+  let interactionEpoch = 0;
+  let intentGeneration = 0;
+  let consumedJumpRequest = -1;
+  /** @type {string | null} */
+  let interactionContext = null;
+  const visibility = createFocusVisibility();
+  // Passive desktop presence is not permission to capture keys or activate a stale source.
+  const persistent = env.PI_ACTIVITY_STRIP_VISIBILITY !== "focus";
+  const keepsSurface = () => persistent && isNiriSession() && workspace?.is_focused === true;
+  /** @type {import("./focus-visibility.mjs").FocusKind} */
+  let focusKind = "unknown";
+  /** Exact source, retained across explicit panel NULL focus. @type {number | null} */
+  let focusWindowId = null;
+  /** One exact card, or a presence app owning none. @type {"agent" | "neutral" | null} */
+  let focusSourceKind = null;
+  let focusContextValid = false;
+
+  const neutralSource = createNeutralSource(getWindowFacts, env);
+  const presentation = createPanelPresentation({
+    getWindowFacts,
+    getCards: getDisplaySessions,
+    getRawSessions: allSessions,
+    env,
+  });
+
+  function ensureNeutralSource() {
+    if (
+      focusSourceKind !== "neutral" ||
+      neutralSource.holds(workspace?.id, focusWindowId, getDisplaySessions())
+    )
+      return true;
+    invalidateFocus();
+    return false;
+  }
+
+  function clearFocusState() {
+    focusContextValid = false;
+    focusKind = "unknown";
+    focusWindowId = null;
+    focusSourceKind = null;
+    neutralSource.clear();
+    focusedCardId = null;
+    focusedSessionId = null;
+  }
+
+  function invalidateFocus() {
+    presentation.clear();
+    clearFocusState();
+    send();
+  }
+
+  /** Recheck exact ownership: revoke only, never admit new membership from event facts.
+   * @param {(workspace: Record<string, unknown>) => WorkspaceView | null} resolveView
+   */
+  function focusProofMatches(resolveView) {
+    if (focusWindowId === null || !focusContextValid) return true;
+    const current = workspace ? resolveView(workspace) : null;
+    if (focusSourceKind === "neutral") {
+      return (
+        current?.workspace?.id === workspace?.id &&
+        neutralSource.holds(workspace?.id, focusWindowId, current?.sessions ?? [])
+      );
+    }
+    return agentSourceMatches(getDisplaySessions(), current, workspace?.id, focusWindowId);
+  }
 
   function allSessions() {
     return agentSessions.length > 0 ? [...snapshot.sessions, ...agentSessions] : snapshot.sessions;
@@ -57,8 +142,7 @@ export function createNativePanelProjection({ isNiriSession, publish }) {
       });
     }
     if (!akTasks) return cards;
-    // Dead-session detection must consider every live session, including cards projected onto
-    // other workspaces, so a claim is only orphaned when no live session anywhere holds it.
+    // Claims are orphaned only when no live session anywhere (including other workspaces) holds them.
     const liveSessionIds = new Set(
       rawSessions.map((session) => String(session.sessionId ?? "")).filter(Boolean),
     );
@@ -74,15 +158,66 @@ export function createNativePanelProjection({ isNiriSession, publish }) {
   function currentView() {
     revision += 1;
     const sessions = getDisplaySessions();
+    if (
+      selectionContradictsSource(workspace, focusWindowId) ||
+      (focusSourceKind === "neutral" &&
+        !neutralSource.holds(workspace?.id, focusWindowId, sessions))
+    )
+      clearFocusState();
+    // NULL continues only an exact admitted owner, never another card after owner loss/ambiguity.
+    if (
+      focusSourceKind !== "neutral" &&
+      (focusKind === "agent" || (focusKind === "none" && focusWindowId !== null)) &&
+      (focusWindowId === null || visibleCardsForWindow(sessions, focusWindowId).length !== 1)
+    ) {
+      clearFocusState();
+    }
+    let owner =
+      focusSourceKind === "neutral"
+        ? undefined
+        : sessions.find((card) => card.windowId === focusWindowId && card.surfaceVisible !== false);
+    const rawOwner = owner
+      ? projectSessionCards(allSessions(), null).find((card) => card.cardId === owner?.cardId)
+      : undefined;
+    // Newly added publishers cannot inherit an admission established for a smaller set.
+    if (owner && JSON.stringify(publisherSet(owner)) !== JSON.stringify(publisherSet(rawOwner))) {
+      clearFocusState();
+      owner = undefined;
+    }
+    const facts = {
+      workspaceId: workspace?.id ?? null,
+      focus: isNiriSession() ? focusKind : "unknown",
+      hasCards: workspace?.is_focused === true && sessions.length > 0,
+    };
+    // Source identity survives own release/NULL, not app switch/admission loss; presence is separate.
+    const sourceHeld = focusSourceKind === "neutral" ? focusWindowId !== null : owner !== undefined;
+    const context =
+      focusContextValid &&
+      workspace?.is_focused === true &&
+      ["agent", "neutral", "none"].includes(focusKind) &&
+      sourceHeld
+        ? focusSourceKind === "neutral"
+          ? neutralSource.context(workspace?.id, focusWindowId)
+          : sourceIdentity(workspace?.id, focusWindowId, owner)
+        : null;
+    if (context !== interactionContext) {
+      interactionEpoch += 1;
+      visibility.resetKeyboard();
+      interactionContext = context;
+    }
+    const focusVisible = presentation.visible(visibility.observe(facts), workspace, focusWindowId);
     return {
-      protocol: 1,
+      protocol: PANEL_PROTOCOL,
       type: "view",
       revision,
-      visible: isNiriSession() ? Boolean(workspace?.is_focused && sessions.length > 0) : true,
+      interactionEpoch,
+      visible: keepsSurface() || focusVisible,
       focusedSessionId,
       focusedCardId,
       generatedAt: snapshot.generatedAt,
       sessions,
+      windows: directory,
+      hotkey,
     };
   }
 
@@ -100,6 +235,159 @@ export function createNativePanelProjection({ isNiriSession, publish }) {
 
   return {
     getDisplaySessions,
+    // Observe existing fields only: no publish, epoch advancement, admission or query access.
+    diagnostics: () => ({
+      persistentPresentation: keepsSurface(),
+      focus: focusKind,
+      source: focusSourceKind,
+      contextValid: focusContextValid,
+      eligible: visibility.isEligible(),
+      interactionEpoch,
+      keyboardAuthorization: visibility.keyboardMode(),
+    }),
+    /** Reserve ownership before sending; cancel on a failed write or panel exit. */
+    requestKeyboard: (clickThrough = false) => {
+      if (!ensureNeutralSource()) return null;
+      const request = ++nextKeyboardRequest;
+      if (!visibility.requestKeyboard(request, clickThrough)) return null;
+      intentGeneration += 1;
+      return request;
+    },
+    /** @param {number} epoch @param {number} token @param {boolean} clickThrough */
+    requestHoverKeyboard(epoch, token, clickThrough) {
+      if (!ensureNeutralSource() || epoch !== interactionEpoch) return null;
+      const request = ++nextKeyboardRequest;
+      if (!visibility.requestKeyboard(request, clickThrough, "hover", token)) return null;
+      intentGeneration += 1;
+      return request;
+    },
+    getInteractionEpoch: () => interactionEpoch,
+    keyboardMode: () => visibility.keyboardMode(),
+    /** @param {number} request */
+    ownsKeyboardRequest: (request) => visibility.ownsRequest(request),
+    /** @param {number} token */
+    cancelHoverKeyboard(token) {
+      const cancelled = visibility.cancelHover(token);
+      if (cancelled) intentGeneration += 1;
+      return cancelled;
+    },
+    cancelKeyboard() {
+      intentGeneration += 1;
+      visibility.resetKeyboard();
+    },
+    /** One accepted action, not a lease to capture keys. Own release must not cancel it.
+     * @param {number} request @param {number} epoch */
+    acceptJumpIntent(request, epoch) {
+      if (!ensureNeutralSource()) return null;
+      if (
+        !visibility.ownsRequest(request) ||
+        !visibility.isEligible() ||
+        epoch !== interactionEpoch ||
+        !interactionContext ||
+        !focusContextValid ||
+        focusWindowId === null ||
+        consumedJumpRequest === request
+      )
+        return null;
+      consumedJumpRequest = request;
+      const context = interactionContext;
+      const generation = intentGeneration;
+      const sourceWorkspaceId = workspace?.id;
+      const sourceWindowId = focusWindowId;
+      const sourceKind = focusSourceKind;
+      return {
+        workspaceId: sourceWorkspaceId,
+        windowId: sourceWindowId,
+        allowUnlisted: visibility.keyboardMode() === "explicit",
+        isCurrent: () =>
+          generation === intentGeneration &&
+          epoch === interactionEpoch &&
+          focusContextValid &&
+          context === interactionContext &&
+          sourceKind === focusSourceKind &&
+          ["agent", "neutral", "none"].includes(focusKind),
+        /** @param {WorkspaceView | null} view */
+        matchesSource(view) {
+          if (!view || view.workspace?.id !== sourceWorkspaceId) return false;
+          if (selectionContradictsSource(view.workspace, sourceWindowId)) return false;
+          const kind = view.focusKind ?? "unknown";
+          const owned = visibleCardsForWindow(view.sessions, sourceWindowId);
+          if (sourceKind === "neutral")
+            return (
+              (kind === "none" || (kind === "neutral" && view.focusWindowId === sourceWindowId)) &&
+              neutralSource.holds(sourceWorkspaceId, sourceWindowId, view.sessions) &&
+              neutralSource.context(sourceWorkspaceId, sourceWindowId) === context
+            );
+          if (!["agent", "none"].includes(kind)) return false;
+          return (
+            owned.length === 1 &&
+            (view.focusKind !== "agent" || view.focusedCardId === owned[0]?.cardId) &&
+            sourceIdentity(sourceWorkspaceId, sourceWindowId, owned[0]) === context
+          );
+        },
+      };
+    },
+    /** @param {number} request @param {boolean} active */
+    keyboardChanged: (request, active) => visibility.keyboardChanged(request, active),
+    isEligible: () => visibility.isEligible(),
+    invalidateFocus,
+    /** Revocation-only layout metadata; never admit seat focus or a replacement source.
+     * @param {number} id @param {number | null} windowId
+     * @param {(workspace: Record<string, unknown>) => WorkspaceView | null} resolveView */
+    observeWorkspaceSelection(id, windowId, resolveView) {
+      if (workspace?.id !== id) return;
+      workspace = { ...workspace, active_window_id: windowId };
+      presentation.prepare(workspace, windowId, resolveView);
+      send();
+    },
+    /** @param {number} windowId */
+    invalidateWindowFocus(windowId) {
+      if (windowId === focusWindowId || presentation.involves(windowId)) invalidateFocus();
+    },
+    /** @param {(workspace: Record<string, unknown>) => WorkspaceView | null} resolveView */
+    revalidateWindowFocus(resolveView) {
+      const valid = focusProofMatches(resolveView) && presentation.holds(workspace, resolveView);
+      if (!valid) invalidateFocus();
+      return valid;
+    },
+    /** Authoritative focus-event ids, not app-id/title guesses or delayed panel acknowledgements.
+     * @param {number | null} windowId
+     * @param {(workspace: Record<string, unknown>) => WorkspaceView | null} [resolveView]
+     */
+    publishWindowFocus(windowId, resolveView) {
+      if (windowId !== null && resolveView) presentation.prepare(workspace, windowId, resolveView);
+      const cards = getDisplaySessions();
+      const facts = windowId === null ? null : getWindowFacts(windowId);
+      focusKind = !focusContextValid
+        ? "unknown"
+        : windowId === null
+          ? "none"
+          : classifyAdmittedWindowFocus(
+              windowId,
+              cards,
+              facts?.workspace_id === workspace?.id ? facts : null,
+              env,
+            );
+      // NULL may be a layer surface: retain the source ring and scroll position, not input authority.
+      if (focusKind !== "none") {
+        const current =
+          focusKind === "agent"
+            ? cards.find((card) => card.windowId === windowId && card.surfaceVisible !== false)
+            : null;
+        focusedCardId = current ? String(current.cardId) : null;
+        focusedSessionId = current ? String(current.sessionId) : null;
+      }
+      if (focusKind === "agent" || focusKind === "neutral") {
+        focusWindowId = windowId;
+        focusSourceKind = focusKind;
+        neutralSource.admit(focusKind === "neutral" ? facts : null);
+      } else if (focusKind !== "none") {
+        focusWindowId = null;
+        focusSourceKind = null;
+      }
+      if (resolveView && !focusProofMatches(resolveView)) clearFocusState();
+      send();
+    },
     getRawSessions: allSessions,
     /** Broker-published records only, for comparisons against a broker snapshot. */
     getBrokerSessions: () => snapshot.sessions,
@@ -107,21 +395,48 @@ export function createNativePanelProjection({ isNiriSession, publish }) {
     setAgentSessions(records) {
       agentSessions = Array.isArray(records) ? records : [];
     },
-    /**
-     * Replace the read-only AK task data joined onto cards. An empty refresh clears every chip;
-     * `null` data (AK never read) leaves cards untouched, which is how the strip stays unchanged
-     * when AK is absent.
+    /** Replace read-only AK chips: empty clears them; null (never read) leaves cards untouched.
      * @param {{claims: import("../common/contracts.ts").AkTaskClaim[]; deferred: import("../common/contracts.ts").AkTaskDeferred[]} | null} state
      */
     setAkTasks(state) {
       akTasks = state;
       send();
     },
-    /** @param {string} targetId */
-    resolveTarget: (targetId) => resolveSnapshotSession(getDisplaySessions(), targetId),
+    /** Resolve a current card or a cross-workspace directory entry.
+     * @param {string} targetId */
+    resolveTarget: (targetId) =>
+      resolveSnapshotSession(getDisplaySessions(), targetId) ??
+      directoryCards.get(targetId) ??
+      null,
+    /** @param {number} windowId */
+    hasDirectoryWindow: (windowId) => directory.some((entry) => entry.windowId === windowId),
+    /** @param {number} windowId */
+    getDirectoryWindowIdentities: (windowId) =>
+      directory
+        .filter((entry) => entry.windowId === windowId)
+        .map((entry) =>
+          sourceIdentity(entry.workspaceId, windowId, directoryCards.get(entry.cardId)),
+        ),
+    /** Replace the window list, published with the next view.
+     * @param {{entries: import("../common/workspace-view.mjs").WindowDirectoryEntry[]; cards: Map<string, SessionRecord>}} next
+     */
+    setDirectory(next) {
+      directory = next.entries;
+      directoryCards = next.cards;
+    },
     /** @param {WorkspaceView} view */
     publishWorkspaceView(view) {
+      presentation.prepareView(view, focusWindowId);
+      const sameWorkspace = Number.isInteger(workspace?.id) && view.workspace?.id === workspace?.id;
+      const retainedCardId = sameWorkspace ? focusedCardId : null;
+      const retainedSessionId = sameWorkspace ? focusedSessionId : null;
+      if (!sameWorkspace) {
+        focusWindowId = null;
+        focusSourceKind = null;
+      }
       workspace = view.workspace ?? null;
+      focusContextValid = Number.isInteger(workspace?.id) && workspace?.is_focused === true;
+      focusKind = view.focusKind ?? "unknown";
       workspaceCardIds = new Set(view.sessions.map((session) => String(session.cardId ?? "")));
       workspaceRecordKeys = new Set(
         view.sessions.flatMap((session) =>
@@ -145,6 +460,27 @@ export function createNativePanelProjection({ isNiriSession, publish }) {
       );
       focusedSessionId = view.focusedSessionId;
       focusedCardId = view.focusedCardId ?? null;
+      // Under NULL the established source keeps its current card (see publishWindowFocus).
+      if (
+        focusKind === "none" &&
+        focusWindowId !== null &&
+        retainedCardId &&
+        workspaceCardIds.has(retainedCardId)
+      ) {
+        focusedCardId = retainedCardId;
+        focusedSessionId = retainedSessionId;
+      }
+      if (focusKind === "agent") {
+        focusWindowId = workspacePlacements.get(focusedCardId ?? "")?.windowId ?? null;
+        focusSourceKind = focusWindowId === null ? null : "agent";
+      } else if (focusKind === "neutral") {
+        focusWindowId = Number.isInteger(view.focusWindowId) ? Number(view.focusWindowId) : null;
+        focusSourceKind = focusWindowId === null ? null : "neutral";
+        neutralSource.admit(focusWindowId === null ? null : getWindowFacts(focusWindowId));
+      } else if (focusKind !== "none") {
+        focusWindowId = null;
+        focusSourceKind = null;
+      }
       send();
     },
     send,

package/src/native/panel-protocol.mjs

@@ -0,0 +1,23 @@
+// Private controller/rendering protocol ONLY. Pi publisher/broker message envelopes are unchanged.
+export const PANEL_PROTOCOL = 2;
+/** Fatal readiness/event gate, even for unverified development overrides. No view or command
+ * may be sent to an incompatible child, and a late ready cannot undo the rejection.
+ * @param {import("node:child_process").ChildProcessWithoutNullStreams & {_protocolError?: string}} child
+ * @param {{protocol?: unknown}} event
+ * @param {{state?: string; error?: string | null}} status @param {() => void} revoke */
+export function admitPanelEvent(child, event, status, revoke) {
+  if (child._protocolError) return false;
+  if (event.protocol === PANEL_PROTOCOL) return true;
+  child._protocolError =
+    "Native panel private protocol mismatch: expected " +
+    PANEL_PROTOCOL +
+    ", received " +
+    String(event.protocol) +
+    ". Rebuild/use a matching controller and panel.";
+  revoke();
+  status.state = "error";
+  status.error = child._protocolError;
+  child.stdin.end();
+  child.kill("SIGTERM");
+  return false;
+}

package/src/native/panel-window-jump.mjs

@@ -0,0 +1,90 @@
+import { resolveFocusedWorkspaceView, resolveWindowDirectory } from "../common/workspace-view.mjs";
+import { sourceIdentity } from "./interaction-context.mjs";
+import { createWindowJump } from "./window-jump.mjs";
+/** The SAME production binding is used by native event consumption and controlled pipe-race tests.
+ * @param {{projection: ReturnType<typeof import("./panel-projection.mjs").createNativePanelProjection>;
+ * getWindowFacts: (id: number) => Record<string, unknown> | null;
+ * placementOptions: import("../common/workspace-view.mjs").ResolveOptions;
+ * isNiriSession: () => boolean; readWindows: () => Promise<Record<string, unknown>[]>;
+ * readWorkspaces: () => Promise<Record<string, unknown>[]>;
+ * focusWindow: (id: number) => Promise<unknown>; reconcile: () => void}} options */
+export function createPanelWindowJump({
+  projection,
+  placementOptions,
+  getWindowFacts,
+  ...options
+}) {
+  /** @param {{windowId?: unknown; request?: unknown; epoch?: unknown}} event */
+  return async function requestJump(event) {
+    const intent = projection.acceptJumpIntent(Number(event.request), Number(event.epoch));
+    if (!intent)
+      return { ok: false, error: "Jump has no current authorized source intent; nothing moved." };
+    const sourceFacts = getWindowFacts(intent.windowId);
+    const windowId = Number(event.windowId);
+    const expectedTarget = projection.getDirectoryWindowIdentities(windowId);
+    /** @type {Record<string, unknown>[]} */
+    let workspaces = [];
+    const jump = createWindowJump({
+      ...options,
+      readWindows: async () => {
+        const [windows, freshWorkspaces] = await Promise.all([
+          options.readWindows(),
+          options.readWorkspaces(),
+        ]);
+        workspaces = freshWorkspaces;
+        return windows;
+      },
+      isAdmittedWindow: (id, windows) => {
+        if (!projection.hasDirectoryWindow(id)) return false;
+        const fresh = resolveWindowDirectory(
+          windows,
+          [...new Set(windows.map((w) => w.workspace_id))].map((id) => ({ id })),
+          projection.getRawSessions(),
+          placementOptions,
+        );
+        return fresh.entries.some(
+          (entry) =>
+            entry.windowId === id &&
+            expectedTarget.includes(
+              sourceIdentity(entry.workspaceId, id, fresh.cards.get(entry.cardId)),
+            ),
+        );
+      },
+    });
+    return jump(
+      Number(event.windowId),
+      intent.allowUnlisted && expectedTarget.length === 0,
+      (windows) =>
+        intent.isCurrent() &&
+        Array.isArray(windows) &&
+        Array.isArray(workspaces) &&
+        workspaces.every(
+          (w) =>
+            w &&
+            Number.isInteger(w.id) &&
+            typeof w.is_focused === "boolean" &&
+            (typeof w.name === "string" || Number.isInteger(w.idx)),
+        ) &&
+        new Set(workspaces.map((w) => w.id)).size === workspaces.length &&
+        sourceFacts !== null &&
+        windows.some(
+          (w) =>
+            w?.id === intent.windowId &&
+            w?.workspace_id === intent.workspaceId &&
+            w?.workspace_id === sourceFacts.workspace_id &&
+            w?.pid === sourceFacts.pid &&
+            w?.app_id === sourceFacts.app_id,
+        ) &&
+        windows.every((w) => w && Number.isInteger(w.id) && typeof w.is_focused === "boolean") &&
+        new Set(windows.map((w) => w.id)).size === windows.length &&
+        intent.matchesSource(
+          resolveFocusedWorkspaceView(
+            windows,
+            workspaces,
+            projection.getRawSessions(),
+            placementOptions,
+          ),
+        ),
+    );
+  };
+}