diff --git a/CONTEXT.md b/CONTEXT.md
index ab543c5..23c8cec 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -76,3 +76,17 @@ _Avoid_: host, listen address, exposed interface
 **Pairing URL**:
 The single `http://<bind-host>:<port>/` URL a phone types into its browser to reach the daemon. Surfaced as the `url` field on `/health` and `/diag`, and prepended above the JSON body of `deckctl status`. Prefers IPv4 over IPv6 so a phone on a typical home LAN doesn't get a `http://[::1]:.../` link it can't resolve. The password gate still has to be cleared by every non-localhost client; the pairing URL is a convenience, not a bypass.
 _Avoid_: connection URL, daemon URL
+
+### Session screen state (issue #160)
+
+**Screen locked**:
+The desktop session requires credentials (GNOME lock, `loginctl lock-session` — detected via the `login1` session's `LockedHint`). The client renders the full lock takeover over focus-targeting surfaces, the app badge reads "Screen locked", and the daemon **refuses** presses, key/type injection, jog/trackpad input, and window raising (with an `error` frame, reason `screen_locked`, recorded as `lock_dropped`). Now playing, settings, and the layout editor keep working. Not the same state as the deckd password gate.
+_Avoid_: sign-in, login gate, password screen
+
+**Sign-in needed**:
+The deckd *client-auth* state: an `unauthorized` socket — the user has to type the deckd shared password. The connection status label and aria-live copy. Reserved wording: "locked" belongs to the session state below, never to the password gate.
+_Avoid_: locked, screen locked, auth screen
+
+**Screen blanked**:
+The session isn't on the screen (GNOME screen blank). Detection and *policy* are deliberately separate: blanking alone (`org.gnome.ScreenSaver.GetActive`) with Automatic Screen Lock off keeps input **enabled** — a press wakes the machine, exactly like poking a real keyboard. Only the soft "Screen asleep — press anything to wake" banner shows. Blanked **and** locked is the lock takeover.
+_Avoid_: screen off, standby, sleep
diff --git a/README.md b/README.md
index e966174..d459210 100644
--- a/README.md
+++ b/README.md
@@ -49,6 +49,7 @@ Pre-alpha, but usable day-to-day. Here's what deckd can do today and what's stil
 - [x] **App badge** — the focused app's name, icon, and accent color show in the bottom bar so you can tell at a glance what you're controlling.
 - [x] **Chrome media indicator** — the media icon sprouts a pulsing green dot whenever a media player is playing (passive playback indicator), independent of the browser view.
 - [x] **Now playing** — control any supported media player (Spotify, Firefox, VLC, etc.) from a dedicated chrome view, with album art, per-player transport controls, and now-playing metadata.
+- [x] **Session lock awareness** — when the desktop session locks, the phone swaps to a "Screen locked" takeover and the daemon refuses presses / injection / trackpad / window raising (`--allow-while-locked` opts out); a plain screen blank keeps input live so a press wakes the machine.
 - [x] **Running programs list** — tap a layout-grid icon in the bottom chrome to open a list of every open window on the host, labeled by the layout the window would match. Tap a row to raise (focus) that window and close the list. Enumeration and raise are GNOME-only today (via the focus extension); other backends show the list's "unsupported on this platform" empty state.
 - [x] **VLC media widgets** — full VLC control surface with play/pause, seek, volume, album art. Configurable art sources (VLC embedded art + iTunes fallback).
 - [x] **Live sensor widgets** — meter and stats widgets pushed to the client in real time (CPU %, memory %, etc.), bound to daemon-side sensor sources.
diff --git a/client/src/App.test.tsx b/client/src/App.test.tsx
index 412059e..98d5931 100644
--- a/client/src/App.test.tsx
+++ b/client/src/App.test.tsx
@@ -16,7 +16,7 @@
  */
 import { act, cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { ClientMessage, ServerChromeMedia, ServerLayout } from "./protocol";
+import type { ClientMessage, ServerChromeMedia, ServerLayout, ServerState } from "./protocol";
 
 /** Replace the real socket hook with a controllable fake. The chrome
  * icon's job is to call ``send`` with the right message; the test
@@ -34,16 +34,21 @@ const onLayout = vi.fn<(m: ServerLayout) => void>();
 let mockStatus: "connecting" | "open" | "closed" | "unauthorized" = "open";
 const authenticate = vi.fn();
 const deauthenticate = vi.fn();
+let sessionStateHandler: ((m: ServerState) => void) | null = null;
 vi.mock("./socket", () => ({
   useDeckdSocket: (
     layoutCb: (m: ServerLayout) => void,
     _widgetUpdate: unknown,
     _mediaState: unknown,
     chromeMediaCb: ((m: ServerChromeMedia) => void) | undefined,
+    _confirmRequestCb: unknown,
+    _runningWindowsCb: unknown,
+    sessionStateCb: ((m: ServerState) => void) | undefined,
     _options: unknown,
   ) => {
     onLayout.mockImplementation(layoutCb);
     chromeMediaHandler = chromeMediaCb ?? null;
+    sessionStateHandler = sessionStateCb ?? null;
     return {
       get status() {
         return mockStatus;
@@ -914,11 +919,13 @@ describe("App — aria-live announcements", () => {
     expect(screen.getByRole("status").textContent).toBe("Reconnecting");
   });
 
-  it("announces a locked status change", () => {
+  it("announces a sign-in-needed status change (issue #160 rename)", () => {
     const { rerender } = render(<App />);
     mockStatus = "unauthorized";
     rerender(<App />);
-    expect(screen.getByRole("status").textContent).toBe("Locked");
+    // Issue #160: "locked" now belongs to the desktop session; the
+    // deckd-password gate is "sign-in needed".
+    expect(screen.getByRole("status").textContent).toBe("Sign-in needed");
   });
 
   it("announces connected when returning from closed", () => {
@@ -1017,3 +1024,89 @@ describe("App — accessibility CSS classes", () => {
     expect(app?.classList.contains("a11y-reduce-motion")).toBe(true);
   });
 });
+
+/* -------------------------------------------------------------------------
+ * Session lock / blank awareness (issue #160): the ``state`` frames drive
+ * the takeover; presses stay enabled under a blank (wake from the phone).
+ * --------------------------------------------------------------------- */
+
+describe("App — session lock takeover", () => {
+  afterEach(cleanup);
+  beforeEach(() => {
+    send.mockReset();
+    sessionStateHandler = null;
+    mockStatus = "open";
+    window.history.replaceState(null, "", "/?demo=default");
+  });
+
+  it("replaces the grid with the lock takeover when locked", () => {
+    render(<App />);
+    expect(screen.getByRole("button", { name: /open/i })).toBeTruthy();
+    act(() => sessionStateHandler?.({ type: "state", locked: true, blanked: false }));
+    expect(screen.getAllByText("Screen locked").length).toBeGreaterThan(0);
+    expect(screen.getByText(/Controls resume when you unlock/)).toBeTruthy();
+  });
+
+  it("names the host in the lock copy", () => {
+    render(<App />);
+    act(() => sessionStateHandler?.({ type: "state", locked: true, blanked: false }));
+    expect(screen.getByText(/localhost/)).toBeTruthy();
+  });
+
+  it("keeps the connection dot's 'live' status while locked", () => {
+    render(<App />);
+    act(() => sessionStateHandler?.({ type: "state", locked: true, blanked: false }));
+    expect(screen.getByText("live")).toBeTruthy();
+  });
+
+  it("reads 'Screen locked' on the app badge while locked", () => {
+    render(<App />);
+    act(() => sessionStateHandler?.({ type: "state", locked: true, blanked: false }));
+    const badge = document.querySelector(".app-badge-name, .app-name");
+    expect(badge?.textContent).toBe("Screen locked");
+  });
+
+  it("disables the running-programs and trackpad chrome buttons while locked", () => {
+    render(<App />);
+    act(() => sessionStateHandler?.({ type: "state", locked: true, blanked: false }));
+    const windowsBtn = screen.getByRole("button", { name: /running programs/i });
+    const trackpadBtn = screen.getByRole("button", { name: /manual control/i });
+    expect(windowsBtn.getAttribute("disabled")).toBe("");
+    expect(trackpadBtn.getAttribute("disabled")).toBe("");
+  });
+
+  it("announces lock restoration and restores the grid on unlock", () => {
+    render(<App />);
+    act(() => sessionStateHandler?.({ type: "state", locked: true, blanked: false }));
+    expect(screen.getAllByText("Screen locked").length).toBeGreaterThan(0);
+    act(() => sessionStateHandler?.({ type: "state", locked: false, blanked: false }));
+    expect(screen.queryByText("Screen locked")).toBeNull();
+    expect(screen.getByRole("button", { name: /open/i })).toBeTruthy();
+  });
+
+  it("shows the asleep banner (input stays enabled) on blank-without-lock", () => {
+    render(<App />);
+    act(() => sessionStateHandler?.({ type: "state", locked: false, blanked: true }));
+    expect(screen.getByText(/Screen asleep — press anything to wake/)).toBeTruthy();
+    // Grid buttons are still rendered (they can press-awake the host).
+    expect(screen.getByRole("button", { name: /open/i })).toBeTruthy();
+  });
+
+  it("appends the lock state into the aria-live stream", () => {
+    render(<App />);
+    act(() => sessionStateHandler?.({ type: "state", locked: true, blanked: false }));
+    // The sr-only live region shares its text with the visible lock card;
+    // assert the announcement landed through the second status region.
+    expect(screen.getAllByText("Screen locked").length).toBeGreaterThan(0);
+  });
+
+  it('renders the running-windows lock empty state naming the host', () => {
+    render(<App />);
+    act(() => sessionStateHandler?.({ type: "state", locked: true, blanked: false }));
+    // The windows view itself is replaced by the takeover; drive the
+    // component contract through its props instead (lockedHost).
+    // Covered indirectly here by asserting the disabled button; the list
+    // slot itself is covered in RunningWindowsList.test.tsx.
+    expect(screen.getByRole("button", { name: /running programs/i }).getAttribute("disabled")).toBe("");
+  });
+});
diff --git a/client/src/App.tsx b/client/src/App.tsx
index c5eebd0..e12492b 100644
--- a/client/src/App.tsx
+++ b/client/src/App.tsx
@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { Pencil as PencilIcon, Settings as SettingsIcon, Globe as GlobeIcon } from "lucide-react";
+import { Lock as LockIcon, Moon as MoonIcon, Pencil as PencilIcon, Settings as SettingsIcon, Globe as GlobeIcon } from "lucide-react";
 import { LayoutGrid as LayoutGridIcon, Music as MusicIcon, PointerIcon } from "lucide-react";
 import { useDeckdSocket } from "./socket";
 import { ButtonGrid } from "./ButtonGrid";
@@ -38,6 +38,7 @@ import type {
   ServerChromeMedia,
   ServerLayout,
   ServerRunningWindows,
+  ServerState,
   WindowListEntry,
 } from "./protocol";
 import { EDITOR_VIEW_ID, MPRIS_VIEW_ID, WINDOWS_VIEW_ID } from "./protocol";
@@ -62,9 +63,23 @@ const STATUS_LABEL: Record<SocketStatus, string> = {
   open: "live",
   connecting: "reconnecting",
   closed: "disconnected",
-  unauthorized: "locked",
+  // Issue #160 naming collision fix: "locked" now belongs to the
+  // *desktop session* state ("Screen locked"). The deckd-password gate
+  // is "sign-in needed".
+  unauthorized: "sign-in needed",
 };
 
+/** The host the socket is driving. Matters under lock (issue #160) when
+ *  one phone drives two machines: the takeover names which screen needs
+ *  unlocking. The page host is the daemon (served directly or proxied). */
+const HOSTNAME = (() => {
+  try {
+    return window.location.hostname || "your computer";
+  } catch {
+    return "your computer";
+  }
+})();
+
 export function App() {
   // Demo mode (``?demo=<name>``): render a fixture layout with the socket
   // disabled, so the client can be viewed without a daemon. Null in normal
@@ -177,6 +192,14 @@ export function App() {
   // platform" empty state in the meantime (issue #120 decision 8).
   const [runningWindows, setRunningWindows] = useState<WindowListEntry[] | undefined>(undefined);
   const onRunningWindows = useCallback((m: ServerRunningWindows) => setRunningWindows(m.windows), []);
+  // Two-state session screen awareness (issue #160). ``null`` until the
+  // first ``state`` frame arrives — both halves read false, which is
+  // exactly what a daemon without lock detection ever pushes. ``locked``
+  // drives the lock takeover + daemon-side gated refusals; ``blanked``
+  // (without lock) drives only the soft "asleep" banner and keeps
+  // presses enabled so the first tap wakes the machine.
+  const [sessionState, setSessionState] = useState<ServerState | null>(null);
+  const onSessionState = useCallback((m: ServerState) => setSessionState(m), []);
   // Demo mode has no socket, so seed the media store once on mount with the
   // fixture readings — otherwise a media widget renders as "unavailable".
   const isDemo = demoLayout !== null;
@@ -213,6 +236,7 @@ export function App() {
     onChromeMedia,
     onConfirmRequest,
     onRunningWindows,
+    onSessionState,
     { enabled: !demoLayout && !isPlayground },
   );
   const playgroundSocket = usePlaygroundDaemon(
@@ -226,6 +250,11 @@ export function App() {
   );
   const { status, send, authenticate, deauthenticate, hasPassword } =
     isPlayground ? playgroundSocket : realSocket;
+  // Derived two-state (issue #160). ``locked`` requires credentials —
+  // full takeover of focus-targeting surfaces. ``blanked`` without
+  // ``locked`` is the soft "asleep, press anything to wake" state.
+  const screenLocked = sessionState?.locked ?? false;
+  const screenBlanked = !screenLocked && (sessionState?.blanked ?? false);
   // Look the pressed widget up in the active layout so the modal
   // can show its label / icon (the daemon doesn't send command text
   // on the wire). If the layout has rotated away between the press
@@ -446,6 +475,10 @@ export function App() {
         return;
       }
       if (e.altKey || e.ctrlKey || e.metaKey) return;
+      // Issue #160: while locked, the surfaces these two shortcuts
+      // open (trackpad manual injection, running-windows raise) are
+      // gated — don't invite the user into a dead view.
+      if (screenLocked && (e.key === "1" || e.key === "5")) return;
       if (e.key === "1") {
         e.preventDefault();
         viewOriginRef.current = trackpadBtnRef.current;
@@ -475,7 +508,7 @@ export function App() {
     };
     window.addEventListener("keydown", onKey);
     return () => window.removeEventListener("keydown", onKey);
-  }, [navigate, view, openTrackpad, openSettings, toggleNowPlaying, toggleEditor, toggleWindows, send, status]);
+  }, [navigate, view, openTrackpad, openSettings, toggleNowPlaying, toggleEditor, toggleWindows, send, status, screenLocked]);
 
   const jogstripEnabled = layout?.jogstrip_enabled ?? true;
   const statusLabel = STATUS_LABEL[status];
@@ -524,8 +557,19 @@ export function App() {
     if (status === "open") setLiveText("Connected");
     else if (status === "connecting") setLiveText("Reconnecting");
     else if (status === "closed") setLiveText("Disconnected");
-    else if (status === "unauthorized") setLiveText("Locked");
+    else if (status === "unauthorized") setLiveText("Sign-in needed");
   }, [status]);
+  // Gesture... issue #160: announce lock / wake transitions so a screen
+  // reader learns the takeover replaced the grid and why.
+  const prevSessionState = useRef(sessionState);
+  useEffect(() => {
+    if (prevSessionState.current === sessionState) return;
+    prevSessionState.current = sessionState;
+    // eslint-disable-next-line react-hooks/set-state-in-effect
+    if (sessionState?.locked === true) setLiveText("Screen locked");
+    else if (sessionState?.blanked === true) setLiveText("Screen asleep");
+    else if (sessionState != null) setLiveText("Home");
+  }, [sessionState]);
   useEffect(() => {
     if (prevLayout.current === layout) return;
     prevLayout.current = layout;
@@ -543,7 +587,11 @@ export function App() {
   // absent theme leaves the badge on the default chrome treatment. A
   // layout declaring neither an icon nor a theme renders the chrome
   // unchanged (bold text, no pill) so existing layouts look identical.
-  const appName = layout
+  // Issue #160: while the session is locked the badge reads "Screen
+  // locked" in place of the app name.
+  const appName = screenLocked
+    ? "Screen locked"
+    : layout
     ? (layout.display_name?.trim() || layout.app) + programSuffix
     : "deckd";
   const appTheme = layout?.theme?.trim() || null;
@@ -581,6 +629,19 @@ export function App() {
     );
   }
 
+  // Issue #160: per-capability gate, not a global switch. While the
+  // session is locked, the surfaces that target the focused window
+  // (grid, jogstrip, trackpad) are replaced by the lock takeover;
+  // now playing, settings, and the layout editor keep working (MPRIS
+  // is alive behind the shield, settings are device-local, the editor
+  // writes YAML to disk). The running-windows view is NOT in the
+  // takeover set: its chrome button is disabled while locked, but a
+  // session already on the view renders the list's lock-specific
+  // empty state rather than dead rows (issue #160).
+  const lockBlockedView = view === "layout" || view === "trackpad";
+  const renderLockTakeover = screenLocked && lockBlockedView;
+  const renderBlankBanner = screenBlanked && !screenLocked && view === "layout";
+
   return (
     <>
       <span role="status" className="sr-only">{liveText}</span>
@@ -602,7 +663,23 @@ export function App() {
           }
         >
           <h1 className="sr-only">{headingText}</h1>
-          {view === "trackpad" ? (
+          {renderLockTakeover ? (
+            <div className="lock-takeover" role="status" aria-live="polite">
+              <LockIcon className="lock-takeover-glyph" size={42} aria-hidden />
+              <span className="lock-takeover-title">Screen locked</span>
+              <span className="lock-takeover-sub">
+                {`Controls resume when you unlock ${HOSTNAME}`}
+              </span>
+            </div>
+          ) : (
+            <>
+              {renderBlankBanner && (
+                <div className="lock-banner" role="status" aria-live="polite">
+                  <MoonIcon size={16} aria-hidden />
+                  <span>{`Screen asleep — press anything to wake ${HOSTNAME}`}</span>
+                </div>
+              )}
+              {view === "trackpad" ? (
             <ManualControl
               onPad={pad}
               onTap={padTap}
@@ -701,6 +778,7 @@ export function App() {
             // "Nothing playing" placeholder (decision 8).
             <RunningWindowsList
               windows={wireWindowsToServer(runningWindows)}
+              lockedHost={screenLocked ? HOSTNAME : null}
               onRowTap={(windowId) => {
                 // Stage 3 (#122): raise the tapped window, then close
                 // the overlay back to the focused-app layout. Same
@@ -735,8 +813,10 @@ export function App() {
           ) : (
             <div className="empty">waiting for daemon…</div>
           )}
+            </>
+          )}
         </main>
-        {jogstripEnabled && view !== "settings" && view !== "nowplaying" && view !== "editor" && view !== "windows" && (
+        {jogstripEnabled && !renderLockTakeover && view !== "settings" && view !== "nowplaying" && view !== "editor" && view !== "windows" && (
           <aside
             className="chrome-jogstrip"
             style={{ "--jog-width": jogWidth.width } as CSSProperties}
@@ -773,12 +853,15 @@ export function App() {
             className={`chrome-btn${view === "trackpad" ? " chrome-btn-active" : ""}`}
             aria-label="manual control"
             aria-pressed={view === "trackpad"}
+            disabled={screenLocked}
             onPointerDown={() => {
+              if (screenLocked) return;
               viewOriginRef.current = trackpadBtnRef.current;
               lastChromeFocus.current = trackpadBtnRef.current;
               openTrackpad();
             }}
             onKeyDown={onActivate(() => {
+              if (screenLocked) return;
               viewOriginRef.current = trackpadBtnRef.current;
               lastChromeFocus.current = trackpadBtnRef.current;
               openTrackpad();
@@ -832,17 +915,20 @@ export function App() {
             <PencilIcon size={16} />
           </button>
         </Tooltip>
-        <Tooltip ref={windowsBtnRef} label="running programs">
+        <Tooltip ref={windowsBtnRef} label={screenLocked ? "running programs (locked)" : "running programs"}>
           <button
             className={`chrome-btn${view === "windows" ? " chrome-btn-active" : ""}`}
-            aria-label="running programs"
+            aria-label={screenLocked ? "running programs (locked)" : "running programs"}
             aria-pressed={view === "windows"}
+            disabled={screenLocked}
             onPointerDown={() => {
+              if (screenLocked) return;
               viewOriginRef.current = windowsBtnRef.current;
               lastChromeFocus.current = windowsBtnRef.current;
               toggleWindows();
             }}
             onKeyDown={onActivate(() => {
+              if (screenLocked) return;
               viewOriginRef.current = windowsBtnRef.current;
               lastChromeFocus.current = windowsBtnRef.current;
               toggleWindows();
diff --git a/client/src/RunningWindowsList.test.tsx b/client/src/RunningWindowsList.test.tsx
index c4cb29a..b9ca707 100644
--- a/client/src/RunningWindowsList.test.tsx
+++ b/client/src/RunningWindowsList.test.tsx
@@ -107,4 +107,29 @@ describe("RunningWindowsList", () => {
     fireEvent.keyDown(row, { key: "Enter" });
     expect(onTap).toHaveBeenCalledWith("w1");
   });
-});
\ No newline at end of file
+});
+describe("RunningWindowsList — session lock (issue #160)", () => {
+  it("reuses the windows-empty slot with the lock-specific copy", () => {
+    render(
+      <RunningWindowsList
+        windows={[
+          { window_id: "1", label: "Firefox", icon: null },
+        ]}
+        lockedHost="nixbox"
+      />,
+    );
+    // A populated list must NOT sit silently disabled; the lock state
+    // replaces the rows with a stated reason naming the host.
+    expect(screen.getAllByText(/Screen locked — unlock nixbox to switch windows/).length).toBeGreaterThan(0);
+    expect(document.querySelectorAll(".windows-row").length).toBe(0);
+  });
+
+  it("renders rows normally when not locked", () => {
+    render(
+      <RunningWindowsList
+        windows={[{ window_id: "1", label: "xterm", icon: null }]}
+      />,
+    );
+    expect(screen.getByText("xterm")).toBeTruthy();
+  });
+});
diff --git a/client/src/RunningWindowsList.tsx b/client/src/RunningWindowsList.tsx
index c3a5757..a915a85 100644
--- a/client/src/RunningWindowsList.tsx
+++ b/client/src/RunningWindowsList.tsx
@@ -38,9 +38,23 @@ export type RunningWindowsListProps = {
   /** Per-row tap handler — wired but ignored in v1; stage 3 (#122)
    *  will replace this with a real raise message. */
   onRowTap?: (windowId: string) => void;
+  /** Issue #160: while the desktop session is locked, raise is refused
+   *  daemon-side. Supersedes the rows with the lock-specific empty
+   *  state (reuses the existing ``windows-empty`` slot) naming the host
+   *  to unlock. ``null``/absent = not locked, rows behave normally. */
+  lockedHost?: string | null;
 };
 
-export function RunningWindowsList({ windows, onRowTap }: RunningWindowsListProps) {
+export function RunningWindowsList({ windows, onRowTap, lockedHost }: RunningWindowsListProps) {
+  if (lockedHost) {
+    return (
+      <div className="windows" role="region" aria-label="running programs">
+        <div className="windows-empty">
+          {`Screen locked — unlock ${lockedHost} to switch windows.`}
+        </div>
+      </div>
+    );
+  }
   if (windows === undefined) {
     return (
       <div className="windows" role="region" aria-label="running programs">
diff --git a/client/src/protocol.generated.ts b/client/src/protocol.generated.ts
index 6e0b470..4493ca2 100644
--- a/client/src/protocol.generated.ts
+++ b/client/src/protocol.generated.ts
@@ -100,11 +100,32 @@ export type LayoutMessage = {
   is_default?: boolean;
 };
 
+/**
+ * Daemon -> client push: two-state session screen awareness (issue
+ *     #160).
+ *
+ *     Two states, not one: ``locked`` means *credentials required* (drives
+ *     the daemon-side refusal of focus-targeting input and the client's
+ *     lock takeover), ``blanked`` means *the session isn't on the screen*
+ *     (GNOME screen blank, with or without Automatic Screen Lock) and
+ *     drives only the client's soft "wake" treatment — input stays enabled
+ *     so a press wakes the machine.
+ *
+ *     Pushed on every transition **and** replayed in the connect snapshot
+ *     (``SERVER.push_session_state_snapshot``) so a phone joining mid-lock
+ *     isn't stuck showing a stale layout. Never sent at all when the
+ *     backend can't observe lock state (no ``session_lock`` /
+ *     ``session_blank`` capability) — the client's default false then
+ *     reads as "not aware", and no lock view can strand on-screen.
+ *     
+ */
 export type StateMessage = {
 
   type: "state";
 
   locked: boolean;
+
+  blanked?: boolean;
 };
 
 export type BrightnessMessage = {
diff --git a/client/src/socket.ts b/client/src/socket.ts
index 9d8181a..eeeda2f 100644
--- a/client/src/socket.ts
+++ b/client/src/socket.ts
@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useRef, useState } from "react";
-import type { ClientMessage, ServerChromeMedia, ServerConfirmRequest, ServerLayout, ServerMessage, ServerRunningWindows, ServerWidgetUpdate, MediaState } from "./protocol";
+import type { ClientMessage, ServerChromeMedia, ServerConfirmRequest, ServerLayout, ServerMessage, ServerRunningWindows, ServerState, ServerWidgetUpdate, MediaState } from "./protocol";
 import { wireLayoutToServer, wireWindowsToServer } from "./protocol";
 
 type Status = "connecting" | "open" | "closed" | "unauthorized";
@@ -48,6 +48,7 @@ export function useDeckdSocket(
   onChromeMedia?: (m: ServerChromeMedia) => void,
   onConfirmRequest?: (m: ServerConfirmRequest) => void,
   onRunningWindows?: (m: ServerRunningWindows) => void,
+  onSessionState?: (m: ServerState) => void,
   options: { enabled?: boolean } = {},
 ) {
   const { enabled = true } = options;
@@ -129,12 +130,27 @@ export function useDeckdSocket(
             const cast: ServerRunningWindows = { ...msg, windows: wireWindowsToServer(msg.windows) ?? [] };
             onRunningWindows(cast);
           }
+          // Issue #160: the two-state session screen awareness. Pushed
+          // on every locked/blanked transition and replayed in the
+          // connect snapshot, so a late joiner isn't stalled on a
+          // stale layout. The handler is optional for the same
+          // forward-compat reason as the other chrome-side frames.
+          else if (msg.type === "state" && onSessionState) {
+            onSessionState(msg);
+          }
           else if (msg.type === "error" && msg.reason === "unauthorized") {
             // Wrong/absent password: stop reconnecting and prompt the user.
             unauthorizedRef.current = true;
             setStatus("unauthorized");
             ws.close();
           }
+          else if (msg.type === "error" && msg.reason === "screen_locked") {
+            // A client that missed the state transition (issue #160):
+            // the press was refused daemon-side; surface the lock state
+            // locally so the takeover still appears. The connection
+            // itself is fine — do NOT close or stop reconnecting.
+            onSessionState?.({ type: "state", locked: true, blanked: false });
+          }
         } catch {
           // ignore malformed
         }
@@ -183,7 +199,7 @@ export function useDeckdSocket(
       if (timer) window.clearTimeout(timer);
       wsRef.current?.close();
     };
-  }, [onLayout, onWidgetUpdate, onMediaState, onChromeMedia, onConfirmRequest, onRunningWindows, enabled, gen]);
+  }, [onLayout, onWidgetUpdate, onMediaState, onChromeMedia, onConfirmRequest, onRunningWindows, onSessionState, enabled, gen]);
 
   const send = (msg: ClientMessage) => {
     const ws = wsRef.current;
diff --git a/client/src/style.css b/client/src/style.css
index 7bdb50d..00acd75 100644
--- a/client/src/style.css
+++ b/client/src/style.css
@@ -660,6 +660,56 @@ button:focus-visible {
   margin: auto;
 }
 
+/* ---------------------------------------------------------------------------
+ * Session lock / blank takeover (issue #160): while the desktop session
+ * is locked, focus-targeting surfaces (grid, trackpad, running-windows)
+ * are replaced in full by the lock card. The connection dot stays green
+ * (the socket is fine — reusing the disconnected treatment would send
+ * people off to restart the daemon). ``lock-banner`` is the soft
+ * "asleep, press anything to wake" strip for the blank-without-lock
+ * state, where input deliberately stays enabled.
+ * ------------------------------------------------------------------------- */
+.lock-takeover {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 10px;
+  height: 100%;
+  color: var(--text, #e6ebf0);
+  text-align: center;
+  padding: 20px;
+}
+
+.lock-takeover-glyph {
+  opacity: 0.6;
+}
+
+.lock-takeover-title {
+  font-size: calc(20px * var(--label-scale, 1));
+  font-weight: 700;
+}
+
+.lock-takeover-sub {
+  color: #8a96a3;
+  font-size: calc(14px * var(--label-scale, 1));
+  max-width: 30ch;
+}
+
+.lock-banner {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  padding: 8px 14px;
+  border-radius: 10px;
+  background: #1b222a;
+  border: 1px dashed #2a333d;
+  color: #8a96a3;
+  font-size: calc(13px * var(--label-scale, 1));
+  margin: 8px auto 0 auto;
+}
+
 /* ---------------------------------------------------------------------------
  * Settings / diagnostics view: read-only key/value list shown in place of
  * the grid when the chrome settings button is toggled on.
diff --git a/daemon/deckd/__main__.py b/daemon/deckd/__main__.py
index 3830c18..e646e61 100644
--- a/daemon/deckd/__main__.py
+++ b/daemon/deckd/__main__.py
@@ -36,6 +36,11 @@ async def _run(server: Server) -> None:
     # stays unconditional at the call site. macOS gained the surface
     # in #135 via Quartz CGWindowList.
     server.start_windows_watcher()
+    # Session lock/blank watcher (issue #160). No-op when the backend
+    # lacks the ``session_lock`` / ``session_blank`` capabilities (X11,
+    # headless, macOS until its follow-up) — same shape as the windows
+    # watcher above.
+    server.start_session_state_watcher()
 
     for sig in (signal.SIGINT, signal.SIGTERM):
         loop.add_signal_handler(sig, server_task.cancel)
@@ -127,6 +132,15 @@ def main() -> None:
         action="store_true",
         help="Disable the focus watcher (serve only the default layout)",
     )
+    parser.add_argument(
+        "--allow-while-locked",
+        action="store_true",
+        help=(
+            "Keep actions working while the desktop session is locked "
+            "(issue #160 default: locked sessions refuse presses, key/"
+            "type injection, jog, trackpad, and window raising)."
+        ),
+    )
     parser.add_argument(
         "--client-dist",
         type=Path,
@@ -284,6 +298,7 @@ def _make_dbus_bus(bus_type):
         focus_backend=focus_backend,
         overlay_dir=overlay_dir,
         password=password,
+        allow_while_locked=args.allow_while_locked,
         sensor_manager=default_sensor_manager(),
         media_manager=MediaManager(),
     )
diff --git a/daemon/deckd/platform.py b/daemon/deckd/platform.py
index d9e3e8b..25bdcb3 100644
--- a/daemon/deckd/platform.py
+++ b/daemon/deckd/platform.py
@@ -110,6 +110,29 @@ class SensorReading:
     stale: bool = False
 
 
+@dataclass(frozen=True)
+class SessionState:
+    """Two-state session screen awareness (issue #160).
+
+    Two states, not one — the obvious single ``locked: bool`` driven by
+    ``org.gnome.ScreenSaver.GetActive`` is wrong, because that property
+    goes true for a *blank that hasn't locked yet* and stays true forever
+    when Automatic Screen Lock is off (gating input on it would forfeit
+    "wake my desktop from my phone"):
+
+    - ``locked`` — credentials are required (``login1`` ``LockedHint``,
+      which is the cross-DE half and also catches ``loginctl
+      lock-session``). Drives the daemon-side refusal.
+    - ``blanked`` — the session isn't on the screen (``GnomeScreenSaver``
+      ``ActiveChanged`` / ``GetActive``). Drives only the client UI; a
+      blanked-but-not-locked session keeps input enabled so the first
+      press wakes the shield.
+    """
+
+    locked: bool = False
+    blanked: bool = False
+
+
 class SensorSource:
     """Named data source the daemon pushes to the client.
 
@@ -365,6 +388,29 @@ async def stop(self) -> None:
         the same reason — implementations that own resources override
         this pair together."""
 
+    async def watch_session_state(
+        self, *, interval_s: float = 2.0
+    ) -> AsyncIterator[SessionState]:
+        """Yield a :class:`SessionState` on every locked/blanked transition.
+
+        Only backends that can observe the desktop's lock state
+        (normally the GNOME backend, via ``org.gnome.ScreenSaver`` and
+        the ``login1`` session's ``LockedHint``) override this and
+        advertise the ``session_lock`` / ``session_blank`` capabilities
+        alongside. The default refuses with
+        :class:`UnimplementedCapability`, mirroring
+        :meth:`watch_windows`: the daemon checks the capabilities
+        *before* starting the watcher, so a legacy backend (X11, macOS
+        until its follow-up, headless) never produces a ``state`` frame
+        and the client never strands itself in a lock view it can't
+        clear.
+        """
+        raise UnimplementedCapability(
+            "this backend does not implement watch_session_state",
+            capability="session_lock",
+        )
+        yield  # type: ignore[unreachable]  # make this an async generator for override compat
+
     async def get_active_app(self) -> AppInfo:
         raise NotImplementedError
 
@@ -442,7 +488,24 @@ def capabilities(self) -> frozenset[str]:
         # ``capabilities()`` back down to focus-only (#133), since it has
         # no KWin-side enumeration/raise implementation to back these
         # flags.
-        return frozenset({"watch_active_app", "watch_windows", "raise_window", "raise_app"})
+        #
+        # Session screen awareness (issue #160) joins here too: GNOME can
+        # observe both halves (``org.gnome.ScreenSaver.GetActive`` for
+        # the blank, ``login1`` ``LockedHint`` for the lock), so both
+        # flags are honest on this backend. A backend that can't observe
+        # lock state must NOT advertise them — the client keys its lock
+        # takeover off the ``state`` frames these caps gate, and no
+        # frame must mean no lock view (never a strand).
+        return frozenset(
+            {
+                "watch_active_app",
+                "watch_windows",
+                "raise_window",
+                "raise_app",
+                "session_lock",
+                "session_blank",
+            }
+        )
 
     async def get_active_app(self) -> AppInfo:
         out = await _run(
@@ -540,6 +603,107 @@ async def raise_app(self, identity: str) -> bool:
         )
         return _parse_single_bool_tuple(out)
 
+    async def watch_session_state(
+        self, *, interval_s: float = 2.0
+    ) -> AsyncIterator[SessionState]:
+        """Poll GNOME's blank + lock state and yield on every transition.
+
+        Two gdbus shell-outs per tick — deliberately *poll*, not
+        signal-subscribe: the GNOME native signal pumps for focus and
+        windows arrived later exactly because signal pumps are
+        fragile; here two ``gdbus call``s every couple of seconds is
+        cheap for a desktop daemon, self-healing when the session bus
+        is unreachable, and shares the failure model of every other
+        watcher in this backend (log once, sleep through, keep going).
+
+        Poll cadence is an order of magnitude slower than the focus
+        tick on purpose: lock/blank transitions matter at conversation
+        speed, and a missed transition is self-correcting (the next
+        tick catches it; the client also receives the same state in
+        its connect snapshot).
+        """
+        last: SessionState | None = None
+        while True:
+            try:
+                state = await self._session_state_once()
+            except Exception as exc:  # surface bus failures without killing the watcher
+                log.debug("watch_session_state: %s", exc)
+                state = None
+            if state is not None and state != last:
+                last = state
+                yield state
+            await asyncio.sleep(interval_s)
+
+    async def _session_state_once(self) -> SessionState:
+        blanked = await self._screensaver_active()
+        locked = await self._login_locked_hint()
+        return SessionState(locked=locked, blanked=blanked)
+
+    async def _screensaver_active(self) -> bool:
+        """``org.gnome.ScreenSaver.GetActive`` on the session bus.
+
+        Answers true not only for an actual lock but also for a plain
+        screen blank — callers must pair this with the ``login1``
+        ``LockedHint`` and keep the two states separate (issue #160).
+        Raises :class:`RuntimeError` on failure like every other `_run`-based
+        query; the caller catches and treats it as *not blanked* so a
+        stale/absent ``org.gnome.ScreenSaver`` never gates anything.
+        """
+        out = await _run(
+            "gdbus",
+            "call",
+            "--session",
+            "--dest",
+            "org.gnome.ScreenSaver",
+            "--object-path",
+            "/org/gnome/ScreenSaver",
+            "--method",
+            "org.gnome.ScreenSaver.GetActive",
+        )
+        return _parse_single_bool_tuple(out)
+
+    async def _login_locked_hint(self) -> bool:
+        """``login1`` session ``LockedHint`` on the *system* bus.
+
+        The cross-DE lock signal (caught by GNOME's own lock, KDE, and
+        ``loginctl lock-session`` alike). The session id comes from
+        ``XDG_SESSION_ID`` — the daemon is a per-user session service,
+        so the variable the desktop session exports is authoritative;
+        when absent (rare: ssh-sourced invocation) the call can't be
+        made and the lock half stays false.
+        """
+        session_id = os.environ.get("XDG_SESSION_ID", "")
+        if not session_id:
+            # One-shot warning: the *lock* half silently reading False is
+            # the worst degradation this backend can take — RemoteOps
+            # that shell out would keep running behind a locked screen.
+            if not getattr(self, "_warned_no_session_id", False):
+                self._warned_no_session_id = True
+                log.warning(
+                    "XDG_SESSION_ID unset; login1 LockedHint (session lock "
+                    "detection, issue #160) cannot resolve — the daemon "
+                    "will treat this session as never-locked. Start deckd "
+                    "from inside the desktop session."
+                )
+            return False
+        try:
+            out = await _run(
+                "gdbus",
+                "call",
+                "--system",
+                "--dest",
+                "org.freedesktop.login1",
+                "--object-path",
+                f"/org/freedesktop/login1/session/{session_id}",
+                "--method",
+                "org.freedesktop.DBus.Properties.Get",
+                "org.freedesktop.login1.Session",
+                "LockedHint",
+            )
+        except RuntimeError:
+            return False
+        return _parse_single_bool_tuple(out)
+
 
 class RaiseWindowFailed(RuntimeError):
     """The backend reached the window manager but it declined to raise
@@ -945,6 +1109,14 @@ def capabilities(self) -> frozenset[str]:
         So the honest surface is now the full set. Matches the
         ``## Capability matrix`` in ``docs/PLATFORM-PARITY.md``;
         ``tests/test_platform_parity.py`` enforces the agreement.
+
+        Notably NOT re-added: the GNOME backend's ``session_lock`` /
+        ``session_blank`` flags (issue #160). On KDE the GNOME
+        ``org.gnome.ScreenSaver`` probe doesn't exist; the cross-DE
+        half (``login1`` ``LockedHint``) + ``org.freedesktop.ScreenSaver``
+        dropping-in is a follow-up, and advertising sessions state
+        without a working observer could strand the client in a lock
+        view it can't clear.
         """
         return frozenset(
             {"watch_active_app", "watch_windows", "raise_window", "raise_app"}
diff --git a/daemon/deckd/protocol.py b/daemon/deckd/protocol.py
index e9cd37c..d41d41f 100644
--- a/daemon/deckd/protocol.py
+++ b/daemon/deckd/protocol.py
@@ -93,10 +93,29 @@ class LayoutMessage(BaseModel):
 
 
 class StateMessage(BaseModel):
+    """Daemon -> client push: two-state session screen awareness (issue
+    #160).
+
+    Two states, not one: ``locked`` means *credentials required* (drives
+    the daemon-side refusal of focus-targeting input and the client's
+    lock takeover), ``blanked`` means *the session isn't on the screen*
+    (GNOME screen blank, with or without Automatic Screen Lock) and
+    drives only the client's soft "wake" treatment — input stays enabled
+    so a press wakes the machine.
+
+    Pushed on every transition **and** replayed in the connect snapshot
+    (``SERVER.push_session_state_snapshot``) so a phone joining mid-lock
+    isn't stuck showing a stale layout. Never sent at all when the
+    backend can't observe lock state (no ``session_lock`` /
+    ``session_blank`` capability) — the client's default false then
+    reads as "not aware", and no lock view can strand on-screen.
+    """
+
     model_config = ConfigDict(extra="forbid")
 
     type: Literal["state"]
     locked: bool
+    blanked: bool = False
 
 
 class BrightnessMessage(BaseModel):
diff --git a/daemon/deckd/server.py b/daemon/deckd/server.py
index 05d2f2e..90edbc9 100644
--- a/daemon/deckd/server.py
+++ b/daemon/deckd/server.py
@@ -61,7 +61,7 @@
     from .bind import ResolvedBind
     from .input import KeySink
     from .layouts import Action, Macro, Widget
-    from .platform import AppInfo, PlatformBackend, SensorManager, SensorReading, WindowInfo
+    from .platform import AppInfo, PlatformBackend, SensorManager, SensorReading, SessionState, WindowInfo
 
 from . import PASSWORD_HEADER
 
@@ -569,6 +569,7 @@ def __init__(
         focus_backend: "PlatformBackend | None" = None,
         overlay_dir: Path | None = None,
         password: str | None = None,
+        allow_while_locked: bool = False,
         sensor_manager: "SensorManager | None" = None,
         media_manager: MediaManager | None = None,
         mpris_backend: MprisBackend | None = None,
@@ -714,6 +715,18 @@ async def _timed_call(message: DbusMessage) -> DbusMessage:
         self._sensor_task: asyncio.Task[None] | None = None
         self._media_task: asyncio.Task[None] | None = None
         self._windows_task: asyncio.Task[None] | None = None
+        self._session_state_task: asyncio.Task[None] | None = None
+        # Session screen awareness (issue #160). The backend may take a
+        # couple of seconds to answer the first poll, so the daemon
+        # opens on "nothing wrong" — which is also what the client's
+        # default reads as when the backend never produces a ``state``
+        # frame (no capability, never a strand).
+        self._session_locked = False
+        self._session_blanked = False
+        # ``--allow-while-locked`` opt-out: keeps today's ungated
+        # behaviour for setups that want remote control to run behind
+        # the shield (e.g. fully scripted kiosks).
+        self._allow_while_locked = allow_while_locked
         self._current_error: str | None = None
         self._deckd_window_focused = False
         # Stage 2 (#120 / #126): last pushed running-windows snapshot,
@@ -1109,7 +1122,146 @@ def start_windows_watcher(self) -> asyncio.Task[None] | None:
         self._windows_task = asyncio.create_task(self.run_windows_watcher())
         return self._windows_task
 
-    # -- layouts-dir watcher -------------------------------------------------
+    # -- session lock/blank watcher (issue #160) ------------------------------
+    #
+    # Mirrors the windows-watcher shape: one long-running task, one
+    # backend method, capability-gated at start. Started when the
+    # backend advertises *either* half (``session_lock`` /
+    # ``session_blank``); a backend can only ever hold both or neither
+    # today, but the check reads per-flag so a future backend with only
+    # the lock half doesn't drag the other in.
+
+    async def run_session_state_watcher(self) -> None:
+        """Poll the backend's session state and broadcast a
+        :class:`p.StateMessage` on every transition.
+
+        The state is daemon-wide (one desktop), so the broadcast is
+        global chrome: every connected session sees the transition,
+        matching how ``running_windows`` behaves.
+        """
+        if self.focus_backend is None:
+            return
+        if not self._session_state_capable():
+            log.debug("watch_session_state skipped: backend lacks capability")
+            return
+        try:
+            async for state in self.focus_backend.watch_session_state():
+                await self._on_session_state(state)
+        except Exception as exc:
+            log.warning("session-state watcher exited: %s", exc)
+
+    async def _on_session_state(self, state: "SessionState") -> None:
+        """Watch listener: record, emit a diagnostic event, broadcast (#160).
+
+        The event emission is awaited inline so the watcher stays
+        ordered; the websocket broadcast is a task so one slow client
+        can't stall the loop.
+        """
+        locked, blanked = state.locked, state.blanked
+        if locked == self._session_locked and blanked == self._session_blanked:
+            return
+        self._session_locked = locked
+        self._session_blanked = blanked
+        log.info("session state: locked=%s blanked=%s", locked, blanked)
+        try:
+            await self.events.emit(
+                DiagnosticEvent(
+                    name="session_state",
+                    ts=time.time(),
+                    data={"locked": locked, "blanked": blanked},
+                    correlation_id=current_correlation_id(),
+                )
+            )
+        except Exception as exc:  # diagnostics must never gate the state push
+            log.debug("session_state event emit failed: %s", exc)
+        # Broadcast is a task: one slow client can't stall the watcher.
+        asyncio.create_task(
+            self._broadcast_message(p.StateMessage(type="state", locked=locked, blanked=blanked))
+        )
+
+    async def _broadcast_message(self, msg: "p.ServerMessage") -> None:
+        dead: list[Session] = []
+        for session in list(self._sessions):
+            try:
+                await session.send(msg)
+            except (ConnectionResetError, RuntimeError, ConnectionError):
+                dead.append(session)
+        for session in dead:
+            self._sessions.discard(session)
+
+    def _session_state_capable(self) -> bool:
+        """True when the active backend can observe either half of the
+        session's screen state (``session_lock`` / ``session_blank``).
+        The single gate all three entry points share (watcher start,
+        watcher run, connect snapshot) — issue #160."""
+        return bool(
+            self.focus_backend is not None
+            and {"session_lock", "session_blank"} & self.focus_backend.capabilities()
+        )
+
+    def _lock_gate_active(self) -> bool:
+        """True when presses that target the focused window must refuse.
+
+        Only ``locked`` gates the input path — a blanked-but-not-locked
+        session keeps input enabled so the first press wakes the
+        screen (issue #160).
+        """
+        return self._session_locked and not self._allow_while_locked
+
+    async def _refuse_locked(self, session: Session, what: str, primitive: str) -> None:
+        """Record a lock-refused attempt and reply with an error frame.
+
+        Same shape as :meth:`_injection_blocked` (ring-buffer + metric +
+        ``guard_dropped``-class outcome), plus an :class:`p.ErrorMessage`
+        reply so a client that missed the state transition still
+        surfaces something real to the user (#160).
+        """
+        log.info("[gate] refusing %r %s; session locked", what, primitive)
+        self.metrics.record_action(primitive, "lock_dropped")
+        self.recent_actions.add(
+            ActionRecord(
+                ts=time.time(),
+                layout_id=self._current_app_id,
+                widget_id=str(what)[:64],
+                primitive=primitive,
+                outcome="lock_dropped",
+                command_text=None,
+                error="session locked",
+            )
+        )
+        try:
+            await session.send(p.ErrorMessage(type="error", reason="screen_locked"))
+        except (ConnectionResetError, RuntimeError, ConnectionError):
+            pass
+
+    async def push_session_state_snapshot(self, session: Session) -> None:
+        """Replay the current session state to a just-connected client.
+
+        Capability-gated, not unconditional: a daemon whose backend
+        can't observe lock state never knew about the feature, so its
+        "all-false" answer is indistinguishable from *no session-state
+        surface here* — and never sending a frame keeps the client's
+        default (not locked) honest while old tests / clients stay on
+        the two-frame contract they already know.
+        """
+        backend = self.focus_backend
+        if backend is None or not self._session_state_capable():
+            return
+        await session.send(
+            p.StateMessage(
+                type="state",
+                locked=self._session_locked,
+                blanked=self._session_blanked,
+            )
+        )
+
+    def start_session_state_watcher(self) -> asyncio.Task[None] | None:
+        if self._session_state_task is not None or not self._session_state_capable():
+            return None
+        self._session_state_task = asyncio.create_task(
+            self.run_session_state_watcher()
+        )
+        return self._session_state_task
 
     async def run_layouts_watcher(self) -> None:
         """Long-running task: reload layouts when a YAML file in the layouts
@@ -2259,6 +2411,11 @@ async def _ws_loop(
             # change. A backend without ``watch_windows`` is a silent
             # no-op; the chrome view's empty state is the signal.
             await self.push_running_windows_snapshot(session)
+            # Issue #160: replay the session-state snapshot so a phone
+            # joining mid-lock isn't stuck showing a stale layout. An
+            # unobserving backend answers all-false — the honest
+            # "no session-state surface here".
+            await self.push_session_state_snapshot(session)
             async for raw in ws:
                 if raw.type != WSMsgType.TEXT:
                     continue
@@ -2299,19 +2456,29 @@ async def _dispatch(self, session: Session, data: dict) -> None:
                 await session.push_current()
             return
         if msg_type == "jog":
+            if self._lock_gate_active():
+                return  # high-frequency scroll: drop, don't flood error frames
             msg = p.JogMessage.model_validate(data)
             self.scroll.jog(msg.id, msg.delta)
             return
         if msg_type == "jog_end":
+            if self._lock_gate_active():
+                return
             jog_end = p.JogEndMessage.model_validate(data)
             self.scroll.jog_end(jog_end.id, jog_end.velocity)
             return
         if msg_type == "pad":
+            if self._lock_gate_active():
+                await self._refuse_locked(session, "pad", "pad")
+                return
             pad = p.PadMessage.model_validate(data)
             if self.key_sink is not None:
                 self.key_sink.emit_pointer(pad.dx, pad.dy)
             return
         if msg_type == "pad_tap":
+            if self._lock_gate_active():
+                await self._refuse_locked(session, "pad_tap", "pad_tap")
+                return
             tap = p.PadTapMessage.model_validate(data)
             if self.key_sink is not None:
                 button = "right" if tap.fingers == 2 else "left"
@@ -2319,6 +2486,9 @@ async def _dispatch(self, session: Session, data: dict) -> None:
                 self.key_sink.emit_click(button, False)
             return
         if msg_type == "pad_drag":
+            if self._lock_gate_active():
+                await self._refuse_locked(session, "pad_drag", "pad_drag")
+                return
             drag = p.PadDragMessage.model_validate(data)
             if self.key_sink is not None:
                 self.key_sink.emit_click("left", drag.state == "start")
@@ -2327,6 +2497,12 @@ async def _dispatch(self, session: Session, data: dict) -> None:
             tmsg = p.TypeMessage.model_validate(data)
             if self._injection_blocked(tmsg.text):
                 return
+            # Issue #160: injection lands on the unlock prompt (uinput is a
+            # kernel-level virtual device the shield can't tell from a real
+            # keyboard) — refuse before the sink ever sees it.
+            if self._lock_gate_active():
+                await self._refuse_locked(session, tmsg.text, "type")
+                return
             if self.key_sink is not None:
                 for combo in text_to_combos(tmsg.text):
                     self.key_sink.emit_key(combo)
@@ -2335,6 +2511,9 @@ async def _dispatch(self, session: Session, data: dict) -> None:
             kmsg = p.KeyMessage.model_validate(data)
             if self._injection_blocked(kmsg.combo):
                 return
+            if self._lock_gate_active():
+                await self._refuse_locked(session, kmsg.combo, "key")
+                return
             if self.key_sink is not None:
                 self.key_sink.emit_key(parse_key_combo(kmsg.combo))
             return
@@ -2386,6 +2565,12 @@ async def _dispatch(self, session: Session, data: dict) -> None:
             await session.push_current()
             return
         if msg_type == "raise_window":
+            if self._lock_gate_active():
+                # Issue #160: raising a window needs focus the shield won't
+                # grant — refuse explicitly so the client surfaces why.
+                raise_msg = p.RaiseWindowMessage.model_validate(data)
+                await self._refuse_locked(session, raise_msg.window_id, "raise")
+                return
             raise_msg = p.RaiseWindowMessage.model_validate(data)
             await self._dispatch_raise_window(raise_msg)
             return
@@ -2476,6 +2661,16 @@ def _injection_blocked(self, what: str) -> bool:
 
     async def _dispatch_press(self, session: Session, data: dict) -> None:
         press = p.PressMessage.model_validate(data)
+        # Issue #160: while locked, presses are refused daemon-side —
+        # ``shell:`` / ``url:`` actions are lock-screen bypasses for
+        # arbitrary command execution, and ``key:``/``type:`` subsets of
+        # button macros land on the unlock prompt. The client mirrors
+        # the same policy in its lock takeover; the gate catches a
+        # client that missed the transition. Reply with an
+        # :class:`ErrorMessage` so something real surfaces.
+        if self._lock_gate_active():
+            await self._refuse_locked(session, press.id, "press")
+            return
         widget = self._find_widget(press.id)
         action_widget_id = press.id
         if widget is None and ":" in press.id:
@@ -2868,7 +3063,7 @@ async def start(self) -> None:
             await asyncio.sleep(3600)
 
     async def stop(self) -> None:
-        for task in (self._focus_task, self._windows_task, self._layouts_task, self._sensor_task, self._media_task):
+        for task in (self._focus_task, self._windows_task, self._session_state_task, self._layouts_task, self._sensor_task, self._media_task):
             if task is not None:
                 task.cancel()
                 try:
diff --git a/docs/PLATFORM-PARITY.md b/docs/PLATFORM-PARITY.md
index f7d014e..6a697ee 100644
--- a/docs/PLATFORM-PARITY.md
+++ b/docs/PLATFORM-PARITY.md
@@ -23,6 +23,8 @@ this table exists to make drift between backends visible at a glance.
 | Raise window (`raise_window`) | ✓ extension `RaiseWindow` (#127) | ✓ daemon enqueues → KWin script `QTimer`-polls `DrainPendingRaises`, sets `workspace.activeWindow` (#133) | ✗ | ✓ AppKit + Accessibility (AX half needs the grant) |
 | Window row → layout match (icon / display name) | ✓ `wm_class` matches the layout token | ✓ `resourceClass` → `wm_class`, `desktopFileName` → `sandboxed_app_id` (#133) | n/a | ✓ identity matching is case-insensitive (#140), so `CGWindowList`'s `Firefox` matches the `firefox` token |
 | Raise app (`raise:`) | ✓ extension `RaiseApp` (#137) | ✓ daemon matches identity in its cached list, enqueues the winner (#133) | ✗ | ✗ |
+| Session lock awareness (`session_lock`) | ✓ `login1` session `LockedHint` (system bus, cross-DE signal) | ✗ follow-up — plugs into the `watch_session_state` seam | ✗ | ✗ follow-up |
+| Session blank awareness (`session_blank`) | ✓ `org.gnome.ScreenSaver.GetActive` poll | ✗ (`org.freedesktop.ScreenSaver` would be the source — follow-up) | ✗ | ✗ follow-up |
 | MPRIS media (chrome media icon + `nowplaying`) | ✓ session-bus MPRIS | ✓ | ✓ | ✗ — no session bus; the daemon sends `chrome_media.supported = false` and the view says "unsupported on this platform". A MediaRemote-based equivalent is [#56](https://github.com/jonocodes/deckd/issues/56) |
 | `media` widget (VLC HTTP backend) | ✓ | ✓ | ✓ | ◑ unverified — plain HTTP to VLC's web interface, no platform-specific path |
 | `dbus:` action | ✓ | ✓ | ✓ | ✗ — a Mac has no GNOME/KDE services to call |
diff --git a/docs/REFERENCE.md b/docs/REFERENCE.md
index 7df3a99..ab8e3cc 100644
--- a/docs/REFERENCE.md
+++ b/docs/REFERENCE.md
@@ -6,7 +6,8 @@ Canonical operational reference — daemon flags, `deckctl` commands, environmen
 
 ```
 deckd [--bind ADDR] [--port PORT] [--layouts-dir PATH] [--no-overlay]
-      [--no-focus] [--client-dist PATH] [--password-file PATH] [--no-auth]
+      [--no-focus] [--allow-while-locked] [--client-dist PATH]
+      [--password-file PATH] [--no-auth]
       [--scroll-momentum-friction F] [--scroll-momentum-cutoff C]
       [--log-format {text,json}] [--log-file PATH] [-v]
 ```
@@ -20,6 +21,7 @@ deckd [--bind ADDR] [--port PORT] [--layouts-dir PATH] [--no-overlay]
 | `--layouts-dir PATH` | (required) | Directory of per-app YAML layouts. |
 | `--no-overlay` | off | Skip platform overlay (`layouts.linux/`, `layouts.macos/`). |
 | `--no-focus` | off | Disable the focus watcher; serve only the default layout. |
+| `--allow-while-locked` | off | Keep presses / key / type / trackpad / raise working while the desktop session is locked (issue #160). Default: a locked session refuses those surfaces — the client shows the lock takeover, `shell:`+ friends get a `screen_locked` error, and the refusal is recorded as a `lock_dropped` outcome. |
 | `--client-dist PATH` | none | Serve a built client at `/`. |
 | `--password-file PATH` | `$XDG_CONFIG_HOME/deckd/password` | Shared password file. Generated on first start if absent. |
 | `--no-auth` | off | Disable password auth entirely. |
diff --git a/tests/test_platform.py b/tests/test_platform.py
index d4d9e25..edd4dcc 100644
--- a/tests/test_platform.py
+++ b/tests/test_platform.py
@@ -256,10 +256,18 @@ def test_x11_backend_does_not_advertise_watch_windows() -> None:
 
 
 def test_gnome_backend_advertises_watch_windows() -> None:
-    """GNOME today implements both surfaces; the windows watcher is
+    """GNOME today implements both surfaces plus both session-state
+    halves (issue #160); the windows and session-state watchers are
     started at daemon boot and the chrome list gets a real snapshot."""
     assert GnomeShellFocusBackend().capabilities() == frozenset(
-        {"watch_active_app", "watch_windows", "raise_window", "raise_app"}
+        {
+            "watch_active_app",
+            "watch_windows",
+            "raise_window",
+            "raise_app",
+            "session_lock",
+            "session_blank",
+        }
     )
 
 
diff --git a/tests/test_platform_kde.py b/tests/test_platform_kde.py
index 86281e6..521efec 100644
--- a/tests/test_platform_kde.py
+++ b/tests/test_platform_kde.py
@@ -451,8 +451,15 @@ def test_kde_backend_capabilities_reach_gnome_parity() -> None:
     assert caps == frozenset(
         {"watch_active_app", "watch_windows", "raise_window", "raise_app"}
     )
-    # And the parity is with the GNOME backend it subclasses.
-    assert caps == GnomeShellFocusBackend().capabilities()
+    # Parity with the GNOME backend it subclasses on exactly these four
+    # flags. The GNOME-only session-state pair (``session_lock`` /
+    # ``session_blank``, issue #160) is deliberately NOT inherited: the
+    # GNOME ``org.gnome.ScreenSaver`` probe doesn't exist on KDE, and a
+    # capability whose observer is missing could strand the client in a
+    # lock view it can't clear. KDE's sources are a follow-up.
+    gnome_caps = GnomeShellFocusBackend().capabilities()
+    assert caps <= gnome_caps
+    assert gnome_caps - caps == {"session_lock", "session_blank"}
 
 
 @pytest.mark.asyncio
diff --git a/tests/test_platform_parity.py b/tests/test_platform_parity.py
index 748fe17..3aef1e0 100644
--- a/tests/test_platform_parity.py
+++ b/tests/test_platform_parity.py
@@ -13,13 +13,14 @@
 change must update the table in the same PR, and dishonest advertisement
 (the #133 class) cannot merge.
 
-Scope: only the three compositor-axis capabilities gated by
+Scope: the four compositor-axis capabilities gated by
 ``capabilities()`` (``watch_active_app`` / ``watch_windows`` /
-``raise_window``). The input-injection rows below them are informational
-(no capability flag) and are not checked. See the issue's "Scope /
-decisions" for why. Live-bus verification of the rows is out of scope
-(that's the #129–#131 harness in ``docs/TESTING.md``); this check is
-pure and fast.
+``raise_window`` / the issue-#160 session-state pair
+``session_lock`` / ``session_blank``). The input-injection rows below
+them are informational (no capability flag) and are not checked. See the
+issue's "Scope / decisions" for why. Live-bus verification of the rows is
+out of scope (that's the #129–#131 harness in ``docs/TESTING.md``); this
+check is pure and fast.
 
 macOS is enumerated by advertised flags only — ``MacFocusBackend()``
 constructs without PyObjC and ``capabilities()`` never touches Quartz —
@@ -45,7 +46,13 @@
 # ``capabilities()``. Keyed by the substring the doc's leading table
 # cell uses to name each row (the ``(`flag`)`` in the "Capability"
 # column).
-_GATED_CAPABILITIES = ("watch_active_app", "watch_windows", "raise_window")
+_GATED_CAPABILITIES = (
+    "watch_active_app",
+    "watch_windows",
+    "raise_window",
+    "session_lock",
+    "session_blank",
+)
 
 # Map each matrix column to the backend that column describes. The value
 # is a substring that uniquely identifies the column header; the backend
diff --git a/tests/test_session_lock.py b/tests/test_session_lock.py
new file mode 100644
index 0000000..5f81bd5
--- /dev/null
+++ b/tests/test_session_lock.py
@@ -0,0 +1,304 @@
+"""Session lock/blank awareness: backend detection + daemon gate (issue #160)."""
+from __future__ import annotations
+
+import asyncio
+import json
+from contextlib import asynccontextmanager
+from types import SimpleNamespace
+
+import pytest
+from aiohttp.test_utils import TestServer
+
+from deckd.platform import (
+    GnomeShellFocusBackend,
+    PlatformBackend,
+    SessionState,
+    UnimplementedCapability,
+)
+
+from conftest import LAYOUTS_DIR, make_test_server
+
+
+# ---------------------------------------------------------------------------
+# Backend: session-state detection
+# ---------------------------------------------------------------------------
+
+
+class FakeGdbusBackend(GnomeShellFocusBackend):
+    """GnomeShellFocusBackend with the gdbus shell-out replaced.
+
+    ``scripted`` maps a canned reply to each probe; an unscripted probe
+    raises — the "not on the bus" failure the watcher has to survive.
+    """
+
+    def __init__(self) -> None:
+        self.scripted: dict[str, str] = {}
+
+    async def _fake_run(self, *args: str) -> str:
+        if "--session" in args and "ScreenSaver.GetActive" in args[-1]:
+            canned = self.scripted.get("GetActive", "(false,)")
+        elif "--system" in args and args[-1] == "LockedHint":
+            canned = self.scripted.get("LockedHint")
+            if canned is None:
+                raise RuntimeError("no such session")
+        else:
+            raise RuntimeError(f"unexpected gdbus call: {args}")
+        if canned == "FAIL":
+            raise RuntimeError("bus unreachable")
+        return canned
+
+
+@pytest.fixture
+def fake_gdbus(monkeypatch):
+    backend = FakeGdbusBackend()
+    monkeypatch.setattr("deckd.platform._run", backend._fake_run)
+    monkeypatch.setenv("XDG_SESSION_ID", "c1")  # login1 path resolves via this
+    return backend
+
+
+async def test_default_backend_refuses_session_state() -> None:
+    with pytest.raises(UnimplementedCapability):
+        async for _ in PlatformBackend().watch_session_state():
+            pass
+
+
+async def test_gnome_session_state_once(fake_gdbus) -> None:
+    state = await fake_gdbus._session_state_once()
+    assert state == SessionState(locked=False, blanked=False)
+
+
+async def test_gnome_blank_without_lock(fake_gdbus) -> None:
+    """Blank-but-not-locked: ScreenSaver says active, login1 says awake.
+
+    Everything about issue #160 hinges on this split — a single boolean
+    would gate input on every screen blank and forfeit wake-from-phone.
+    """
+    fake_gdbus.scripted = {"GetActive": "(true,)", "LockedHint": "(false,)"}
+    state = await fake_gdbus._session_state_once()
+    assert state.blanked is True
+    assert state.locked is False
+
+
+async def test_gnome_locked(fake_gdbus) -> None:
+    fake_gdbus.scripted = {"GetActive": "(true,)", "LockedHint": "(true,)"}
+    state = await fake_gdbus._session_state_once()
+    assert state.locked is True
+    assert state.blanked is True
+
+
+async def test_gnome_login1_failure_degrades_to_unlocked(fake_gdbus) -> None:
+    """login1 unreachable → the lock half stays false, never an error."""
+    fake_gdbus.scripted = {"GetActive": "(false,)"}
+    state = await fake_gdbus._session_state_once()
+    assert state.locked is False
+
+
+async def test_gnome_screensaver_failure_survives(fake_gdbus) -> None:
+    """No org.gnome.ScreenSaver on the bus → the probe raises, but the
+    *watcher* keeps polling (failure model of every other watcher here:
+    log once, sleep through, keep going)."""
+    fake_gdbus.scripted = {"GetActive": "FAIL"}
+    with pytest.raises(RuntimeError):
+        await fake_gdbus._session_state_once()
+    gen = fake_gdbus.watch_session_state(interval_s=0.01)
+    # The broken tick is swallowed (yields nothing); the first real
+    # snapshot arrives when the bus starts answering.
+    fake_gdbus.scripted = {"LockedHint": "(false,)", "GetActive": "(true,)"}
+    state = await gen.__anext__()
+    assert state.blanked is True and state.locked is False
+
+
+async def test_watch_session_state_yields_transitions(fake_gdbus) -> None:
+    gen = fake_gdbus.watch_session_state(interval_s=0.01)
+    first = await gen.__anext__()
+    assert first == SessionState(locked=False, blanked=False)
+    # Flip blanked on the bus (auto-lock off: blank, not locked)…
+    fake_gdbus.scripted = {"LockedHint": "(false,)", "GetActive": "(true,)"}
+    transition = await gen.__anext__()
+    assert transition.blanked is True and transition.locked is False
+    # …and lock it later.
+    fake_gdbus.scripted = {"LockedHint": "(true,)", "GetActive": "(true,)"}
+    transition = await gen.__anext__()
+    assert transition.locked is True
+
+
+def test_gnome_capabilities_advertise_both_session_flags() -> None:
+    caps = GnomeShellFocusBackend().capabilities()
+    assert {"session_lock", "session_blank"} <= caps
+
+
+def test_base_backend_does_not_advertise_session_flags() -> None:
+    caps = PlatformBackend().capabilities()
+    assert "session_lock" not in caps
+    assert "session_blank" not in caps
+
+
+# ---------------------------------------------------------------------------
+# Server: connect snapshot
+# ---------------------------------------------------------------------------
+
+
+@asynccontextmanager
+async def _boot_server(locked_backend=True, **kwargs):
+    server, _, _, _ = make_test_server(layouts_dir=LAYOUTS_DIR, **kwargs)
+    # A session-state-capable backend so the connect snapshot is live
+    # (mirrors GNOME in production; a caps-less fake produces NO state
+    # frame at all — see `test_no_capability_no_state_frame`).
+    if locked_backend:
+        server.focus_backend = SimpleNamespace(
+            capabilities=lambda: frozenset({"watch_active_app", "session_lock", "session_blank"}),
+        )
+    ts = TestServer(server.app, host="127.0.0.1")
+    await ts.start_server()
+    try:
+        yield server, ts.port
+    finally:
+        await ts.close()
+
+
+@asynccontextmanager
+async def _connect(port: int):
+    """Open a no-auth WS and yield (ws, layout, state) — the first three pushes."""
+    import websockets as _ws
+
+    async with _ws.connect(f"ws://127.0.0.1:{port}/ws") as ws:
+        layout = json.loads(await asyncio.wait_for(ws.recv(), timeout=2))
+        state = json.loads(await asyncio.wait_for(ws.recv(), timeout=2))
+        yield ws, layout, state
+
+
+@asynccontextmanager
+async def _ws_session(srv):
+    """Open a WS against the ``srv`` fixture; yield (ws, initial layout)."""
+    import websockets as _ws
+
+    async with _ws.connect(srv.ws_url) as ws:
+        layout = json.loads(await asyncio.wait_for(ws.recv(), timeout=2))
+        yield ws, layout
+
+
+async def test_state_snapshot_on_connect() -> None:
+    """A phone connecting *during* a lock gets the state immediately."""
+    async with _boot_server() as (server, port):
+        server._session_locked = True
+        async with _connect(port) as (_, layout, state):
+            pass
+        assert layout["type"] == "layout"
+        assert state == {"type": "state", "locked": True, "blanked": False}
+
+
+async def test_no_capability_no_state_frame() -> None:
+    """A backend with no session-state caps pushes NOTHING at connect.
+
+    The absent frame is the wire-level signal; a client that never
+    receives ``state`` can never strand itself in a lock view.
+    """
+    async with _boot_server(locked_backend=False) as (server, port):
+        import websockets as _ws
+
+        async with _ws.connect(f"ws://127.0.0.1:{port}/ws") as ws:
+            layout = json.loads(await asyncio.wait_for(ws.recv(), timeout=2))
+            try:
+                frame = json.loads(await asyncio.wait_for(ws.recv(), timeout=0.25))
+            except TimeoutError:
+                return
+            assert frame["type"] != "state"
+
+
+# ---------------------------------------------------------------------------
+# Server: press / injection gate at the WebSocket boundary
+# ---------------------------------------------------------------------------
+
+ORNAMENT_WAIT = 0.05
+
+
+async def _recv(ws, timeout: float = 2.0) -> dict:
+    return json.loads(await asyncio.wait_for(ws.recv(), timeout=timeout))
+
+
+async def test_press_refused_while_locked(srv) -> None:
+    async with _ws_session(srv) as (ws, _):
+        srv.server._session_locked = True
+        await ws.send(json.dumps({"type": "press", "id": "open-url"}))
+        reply = await _recv(ws)
+        await asyncio.sleep(ORNAMENT_WAIT)
+    assert reply == {"type": "error", "reason": "screen_locked"}
+    assert not any(kind == "shell" for kind, _ in srv.called)
+
+
+async def test_press_allowed_while_unlocked(srv) -> None:
+    async with _ws_session(srv) as (ws, _):
+        await ws.send(json.dumps({"type": "press", "id": "open-url"}))
+        await asyncio.sleep(ORNAMENT_WAIT)
+    assert any(kind == "shell" for kind, _ in srv.called)
+
+
+async def test_allow_while_locked_opt_out(srv) -> None:
+    """``--allow-while-locked`` restores today's ungated behaviour."""
+    srv.server._allow_while_locked = True
+    srv.server._session_locked = True
+    async with _ws_session(srv) as (ws, _):
+        await ws.send(json.dumps({"type": "press", "id": "open-url"}))
+        await asyncio.sleep(ORNAMENT_WAIT)
+    assert any(kind == "shell" for kind, _ in srv.called)
+
+
+async def test_key_type_gated_while_locked(srv) -> None:
+    async with _ws_session(srv) as (ws, _):
+        srv.server._session_locked = True
+        await ws.send(json.dumps({"type": "key", "combo": "ctrl+l"}))
+        reply = await _recv(ws)
+        await ws.send(json.dumps({"type": "type", "text": "hi"}))
+        await _recv(ws)
+        await ws.send(json.dumps({"type": "pad", "id": "x", "dx": 5, "dy": 0}))
+        await ws.send(json.dumps({"type": "jog", "id": "x", "delta": 3}))
+        await asyncio.sleep(ORNAMENT_WAIT)
+    assert reply == {"type": "error", "reason": "screen_locked"}
+    assert srv.key_sink.events == []
+    assert srv.scroll_sink.deltas == []
+
+
+async def test_key_type_runs_while_unlocked(srv) -> None:
+    async with _ws_session(srv) as (ws, _):
+        await ws.send(json.dumps({"type": "key", "combo": "ctrl+t"}))
+        await asyncio.sleep(ORNAMENT_WAIT)
+    assert srv.key_sink.events
+
+
+async def test_raise_window_gated_while_locked(srv) -> None:
+    async with _ws_session(srv) as (ws, _):
+        srv.server._session_locked = True
+        await ws.send(json.dumps({"type": "raise_window", "window_id": "42"}))
+        reply = await _recv(ws)
+        await asyncio.sleep(ORNAMENT_WAIT)
+    assert reply == {"type": "error", "reason": "screen_locked"}
+
+
+async def test_press_refusal_recorded_in_recent_actions(srv) -> None:
+    async with _ws_session(srv) as (ws, _):
+        srv.server._session_locked = True
+        await ws.send(json.dumps({"type": "press", "id": "open-url"}))
+        await _recv(ws)
+        await asyncio.sleep(ORNAMENT_WAIT)
+    assert "lock_dropped" in {r.outcome for r in srv.server.recent_actions.snapshot()}
+
+
+async def test_transition_broadcast_reaches_session(srv) -> None:
+    from deckd.platform import SessionState as _SS
+
+    async with _ws_session(srv) as (ws, _):
+        await srv.server._on_session_state(_SS(locked=True, blanked=False))
+        frame = await _recv(ws)
+        assert frame == {"type": "state", "locked": True, "blanked": False}
+        # Identical push is deduped, a transition re-fires.
+        await srv.server._on_session_state(_SS(locked=True, blanked=False))
+        await srv.server._on_session_state(_SS(locked=False, blanked=True))
+        frame = await _recv(ws)
+        assert frame["locked"] is False and frame["blanked"] is True
+
+
+async def test_watcher_broadcast_and_capability_refusal(srv) -> None:
+    """start_session_state_watcher is a silent no-op without the caps."""
+    srv.server._last = None
+    assert srv.server.start_session_state_watcher() is None
+