diff --git a/src/tools/_shared/state-header.ts b/src/tools/_shared/state-header.ts
new file mode 100644
index 000000000..8639cda0d
--- /dev/null
+++ b/src/tools/_shared/state-header.ts
@@ -0,0 +1,64 @@
+/**
+ * State Header — unified page-state envelope for tool responses.
+ *
+ * Prepends a 4-line header to text-mode tool responses so agents can
+ * determine which page a snapshot came from without parsing the payload.
+ *
+ * Opt-out: set OPENCHROME_STATE_HEADER=off (case-insensitive) to restore
+ * v1.11.0 byte-identical output.
+ */
+
+export interface PageStateHeader {
+  url: string;
+  title: string;
+  mode: 'ax' | 'dom' | 'css' | 'html' | 'inspect' | 'validate';
+  capturedAt: number; // Unix ms — server wall-clock at response assembly
+  tabId: string;
+}
+
+/**
+ * Returns true when the state header should be included in responses.
+ * Default is enabled; set OPENCHROME_STATE_HEADER=off to disable.
+ */
+export function isStateHeaderEnabled(): boolean {
+  const val = process.env.OPENCHROME_STATE_HEADER;
+  return val === undefined || val.toLowerCase() !== 'off';
+}
+
+/**
+ * Formats the 4-line header text.
+ * The returned string ends with a trailing newline so that
+ * `formatHeaderText(h) + existingPayload` is clean without extra newlines.
+ * Callers that want a blank separator line should append '\n' before the payload.
+ */
+export function formatHeaderText(h: PageStateHeader): string {
+  const capturedAtIso = new Date(h.capturedAt).toISOString();
+  // Escape control characters so a crafted title/url cannot split the fixed
+  // 4-line header into extra lines and spoof subsequent fields.
+  const safeUrl = h.url.replace(/[\r\n]/g, ' ');
+  const safeTitle = h.title.replace(/[\r\n]/g, ' ');
+  return (
+    `- Page URL: ${safeUrl}\n` +
+    `- Page Title: ${safeTitle}\n` +
+    `- Page Mode: ${h.mode}\n` +
+    `- Captured At: ${capturedAtIso}\n`
+  );
+}
+
+/**
+ * Prepends the state header (+ blank line) to a text payload.
+ * Returns the payload unchanged when the header is disabled.
+ */
+export function prependHeaderText(h: PageStateHeader, payload: string): string {
+  if (!isStateHeaderEnabled()) return payload;
+  return formatHeaderText(h) + '\n' + payload;
+}
+
+/**
+ * Merges the state header fields into a JSON-mode response object.
+ * Returns the object unchanged when the header is disabled.
+ */
+export function mergeHeaderJson<T extends object>(h: PageStateHeader, obj: T): T & { state: PageStateHeader } | T {
+  if (!isStateHeaderEnabled()) return obj;
+  return { state: h, ...obj };
+}
diff --git a/src/tools/inspect.ts b/src/tools/inspect.ts
index 00ef92136..af817d106 100644
--- a/src/tools/inspect.ts
+++ b/src/tools/inspect.ts
@@ -14,6 +14,7 @@ import { TOOL_ANNOTATIONS } from '../types/tool-annotations';
 import { getSessionManager } from '../session-manager';
 import { withTimeout } from '../utils/with-timeout';
 import { getAllShadowRoots, querySelectorInShadowRoots } from '../utils/shadow-dom';
+import { prependHeaderText } from './_shared/state-header';
 import {
   formatNodeRefToken,
   getCurrentLoaderId,
@@ -578,8 +579,9 @@ const handler: ToolHandler = async (
     // Footer with page context (always included)
     lines.push(`[Page] ${inspectResult.url} | "${inspectResult.title}"`);
 
+    const inspectPayload = lines.join('\n');
     return {
-      content: [{ type: 'text', text: lines.join('\n') }],
+      content: [{ type: 'text', text: prependHeaderText({ url: inspectResult.url, title: inspectResult.title, mode: 'inspect', capturedAt: Date.now(), tabId }, inspectPayload) }],
     };
   } catch (error) {
     return {
diff --git a/src/tools/page-content.ts b/src/tools/page-content.ts
index 06032b0f5..2df08ad4e 100644
--- a/src/tools/page-content.ts
+++ b/src/tools/page-content.ts
@@ -1,148 +1,155 @@
-/**
- * Page Content Tool - Get HTML content from page
- */
-
-import { MCPServer } from '../mcp-server';
-import { MCPToolDefinition, MCPResult, ToolHandler } from '../types/mcp';
+/**
+ * Page Content Tool - Get HTML content from page
+ */
+
+import { MCPServer } from '../mcp-server';
+import { MCPToolDefinition, MCPResult, ToolHandler } from '../types/mcp';
 import { TOOL_ANNOTATIONS } from '../types/tool-annotations';
-import { getSessionManager } from '../session-manager';
-import { MAX_OUTPUT_CHARS, DEFAULT_NAVIGATION_TIMEOUT_MS } from '../config/defaults';
-import { withTimeout } from '../utils/with-timeout';
-
-const definition: MCPToolDefinition = {
-  name: 'page_content',
-  description: 'Get HTML content from page or element.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      tabId: {
-        type: 'string',
-        description: 'Tab ID to get content from',
-      },
-      selector: {
-        type: 'string',
-        description: 'CSS selector. Omit for full page',
-      },
-      outerHTML: {
-        type: 'boolean',
-        description: 'Return outerHTML vs innerHTML. Default: true',
-      },
-    },
-    required: ['tabId'],
-  },
+import { getSessionManager } from '../session-manager';
+import { MAX_OUTPUT_CHARS, DEFAULT_NAVIGATION_TIMEOUT_MS } from '../config/defaults';
+import { withTimeout } from '../utils/with-timeout';
+import { mergeHeaderJson, isStateHeaderEnabled } from './_shared/state-header';
+
+const definition: MCPToolDefinition = {
+  name: 'page_content',
+  description: 'Get HTML content from page or element.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      tabId: {
+        type: 'string',
+        description: 'Tab ID to get content from',
+      },
+      selector: {
+        type: 'string',
+        description: 'CSS selector. Omit for full page',
+      },
+      outerHTML: {
+        type: 'boolean',
+        description: 'Return outerHTML vs innerHTML. Default: true',
+      },
+    },
+    required: ['tabId'],
+  },
   annotations: TOOL_ANNOTATIONS.page_content,
-};
-
-const handler: ToolHandler = async (
-  sessionId: string,
-  args: Record<string, unknown>
-): Promise<MCPResult> => {
-  const tabId = args.tabId as string;
-  const selector = args.selector as string | undefined;
-  const outerHTML = (args.outerHTML as boolean) ?? true;
-
-  const sessionManager = getSessionManager();
-
-  if (!tabId) {
-    return {
-      content: [{ type: 'text', text: 'Error: tabId is required' }],
-      isError: true,
-    };
-  }
-
-  try {
-    const page = await sessionManager.getPage(sessionId, tabId, undefined, 'page_content');
-    if (!page) {
-      return {
-        content: [{ type: 'text', text: `Error: Tab ${tabId} not found` }],
-        isError: true,
-      };
-    }
-
-    if (selector) {
-      // Get content from specific element
-      const element = await page.$(selector);
-
-      if (!element) {
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify({
-                action: 'page_content',
-                selector,
-                content: null,
-                message: `No element found matching "${selector}"`,
-              }),
-            },
-          ],
-          isError: true,
-        };
-      }
-
-      let html = await withTimeout(page.evaluate(
-        (el: Element, getOuter: boolean) => {
-          return getOuter ? el.outerHTML : el.innerHTML;
-        },
-        element,
-        outerHTML
-      ), 15000, 'page_content');
-
-      const originalLength = html.length;
-      if (html.length > MAX_OUTPUT_CHARS) {
-        html = html.substring(0, MAX_OUTPUT_CHARS) + `\n\n[Truncated: ${originalLength} chars total, showing first ${MAX_OUTPUT_CHARS}]`;
-      }
-
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify({
-              action: 'page_content',
-              selector,
-              outerHTML,
-              contentLength: originalLength,
-              content: html,
-            }),
-          },
-        ],
-      };
-    } else {
-      // Get full page content
-      let html = await withTimeout(page.content(), DEFAULT_NAVIGATION_TIMEOUT_MS, 'page.content()');
-
-      const originalLength = html.length;
-      if (html.length > MAX_OUTPUT_CHARS) {
-        html = html.substring(0, MAX_OUTPUT_CHARS) + `\n\n[Truncated: ${originalLength} chars total, showing first ${MAX_OUTPUT_CHARS}]`;
-      }
-
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify({
-              action: 'page_content',
-              selector: null,
-              contentLength: originalLength,
-              content: html,
-            }),
-          },
-        ],
-      };
-    }
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Page content error: ${error instanceof Error ? error.message : String(error)}`,
-        },
-      ],
-      isError: true,
-    };
-  }
-};
-
-export function registerPageContentTool(server: MCPServer): void {
-  server.registerTool('page_content', handler, definition);
-}
+};
+
+const handler: ToolHandler = async (
+  sessionId: string,
+  args: Record<string, unknown>
+): Promise<MCPResult> => {
+  const tabId = args.tabId as string;
+  const selector = args.selector as string | undefined;
+  const outerHTML = (args.outerHTML as boolean) ?? true;
+
+  const sessionManager = getSessionManager();
+
+  if (!tabId) {
+    return {
+      content: [{ type: 'text', text: 'Error: tabId is required' }],
+      isError: true,
+    };
+  }
+
+  try {
+    const page = await sessionManager.getPage(sessionId, tabId, undefined, 'page_content');
+    if (!page) {
+      return {
+        content: [{ type: 'text', text: `Error: Tab ${tabId} not found` }],
+        isError: true,
+      };
+    }
+
+    if (selector) {
+      // Get content from specific element
+      const element = await page.$(selector);
+
+      if (!element) {
+        const missingBody = {
+          action: 'page_content',
+          selector,
+          content: null,
+          message: `No element found matching "${selector}"`,
+        };
+        const missingWithState = isStateHeaderEnabled()
+          ? mergeHeaderJson(
+              { url: page.url(), title: await page.title(), mode: 'html' as const, capturedAt: Date.now(), tabId },
+              missingBody,
+            )
+          : missingBody;
+        return {
+          content: [{ type: 'text', text: JSON.stringify(missingWithState) }],
+          isError: true,
+        };
+      }
+
+      let html = await withTimeout(page.evaluate(
+        (el: Element, getOuter: boolean) => {
+          return getOuter ? el.outerHTML : el.innerHTML;
+        },
+        element,
+        outerHTML
+      ), 15000, 'page_content');
+
+      const originalLength = html.length;
+      if (html.length > MAX_OUTPUT_CHARS) {
+        html = html.substring(0, MAX_OUTPUT_CHARS) + `\n\n[Truncated: ${originalLength} chars total, showing first ${MAX_OUTPUT_CHARS}]`;
+      }
+
+      const elementBody = {
+        action: 'page_content',
+        selector,
+        outerHTML,
+        contentLength: originalLength,
+        content: html,
+      };
+      const elementWithState = isStateHeaderEnabled()
+        ? mergeHeaderJson(
+            { url: page.url(), title: await page.title(), mode: 'html' as const, capturedAt: Date.now(), tabId },
+            elementBody,
+          )
+        : elementBody;
+      return {
+        content: [{ type: 'text', text: JSON.stringify(elementWithState) }],
+      };
+    } else {
+      // Get full page content
+      let html = await withTimeout(page.content(), DEFAULT_NAVIGATION_TIMEOUT_MS, 'page.content()');
+
+      const originalLength = html.length;
+      if (html.length > MAX_OUTPUT_CHARS) {
+        html = html.substring(0, MAX_OUTPUT_CHARS) + `\n\n[Truncated: ${originalLength} chars total, showing first ${MAX_OUTPUT_CHARS}]`;
+      }
+
+      const fullPageBody = {
+        action: 'page_content',
+        selector: null,
+        contentLength: originalLength,
+        content: html,
+      };
+      const fullPageWithState = isStateHeaderEnabled()
+        ? mergeHeaderJson(
+            { url: page.url(), title: await page.title(), mode: 'html' as const, capturedAt: Date.now(), tabId },
+            fullPageBody,
+          )
+        : fullPageBody;
+      return {
+        content: [{ type: 'text', text: JSON.stringify(fullPageWithState) }],
+      };
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Page content error: ${error instanceof Error ? error.message : String(error)}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+};
+
+export function registerPageContentTool(server: MCPServer): void {
+  server.registerTool('page_content', handler, definition);
+}
diff --git a/src/tools/read-page.ts b/src/tools/read-page.ts
index 15115e973..dc73f93e2 100644
--- a/src/tools/read-page.ts
+++ b/src/tools/read-page.ts
@@ -16,6 +16,7 @@ import { sanitizeContent } from '../security/content-sanitizer';
 import { getGlobalConfig } from '../config/global';
 import { extractMainContent, toMarkdown } from '../core/extract/html-to-markdown';
 import { getCurrentLoaderId, mintNodeRefSync } from '../core/perception/node-ref';
+import { isStateHeaderEnabled, mergeHeaderJson, prependHeaderText } from './_shared/state-header';
 
 /**
  * Build the `[node_refs]` block that surfaces the #844 backend-node uid
@@ -1236,7 +1237,55 @@ const sanitizedHandler: ToolHandler = async (sessionId, args, context) => {
  * behavior-preserving seam so the feature can be re-enabled safely later.
  */
 const cachedHandler: ToolHandler = async (sessionId, args, context) => {
-  return sanitizedHandler(sessionId, args, context);
+  const result = await sanitizedHandler(sessionId, args, context);
+  if (!isStateHeaderEnabled() || result.isError || !result.content) return result;
+
+  const tabId = typeof args.tabId === 'string' ? args.tabId : '';
+  if (!tabId) return result;
+
+  let page: Awaited<ReturnType<ReturnType<typeof getSessionManager>['getPage']>> | null = null;
+  try {
+    page = await getSessionManager().getPage(sessionId, tabId);
+  } catch {
+    page = null;
+  }
+  if (!page) return result;
+
+  let url = '';
+  let title = '';
+  try {
+    url = page.url() || '';
+  } catch {
+    url = '';
+  }
+  try {
+    title = await page.title();
+  } catch {
+    title = '';
+  }
+
+  const requestedMode = typeof args.mode === 'string' ? args.mode : 'dom';
+  const mode = ['ax', 'dom', 'css', 'semantic', 'markdown'].includes(requestedMode)
+    ? requestedMode
+    : 'dom';
+  const headerMode = mode === 'markdown' ? 'html' : mode;
+  const header = { url, title, mode: headerMode as 'ax' | 'dom' | 'css' | 'html', capturedAt: Date.now(), tabId };
+
+  return {
+    ...result,
+    content: result.content.map((block) => {
+      if (block.type !== 'text' || typeof block.text !== 'string') return block;
+      if (mode === 'semantic') {
+        try {
+          const parsed = JSON.parse(block.text) as Record<string, unknown>;
+          return { ...block, text: JSON.stringify(mergeHeaderJson(header, parsed)) };
+        } catch {
+          return { ...block, text: prependHeaderText(header, block.text) };
+        }
+      }
+      return { ...block, text: prependHeaderText(header, block.text) };
+    }),
+  };
 };
 
 export function registerReadPageTool(server: MCPServer): void {
diff --git a/src/tools/validate-page.ts b/src/tools/validate-page.ts
index b2b01ec9e..86b1a4a88 100644
--- a/src/tools/validate-page.ts
+++ b/src/tools/validate-page.ts
@@ -19,6 +19,7 @@ import { getSessionManager } from '../session-manager';
 import { smartGoto } from '../utils/smart-goto';
 import { safeTitle } from '../utils/safe-title';
 import { assertDomainAllowed } from '../security/domain-guard';
+import { isStateHeaderEnabled, prependHeaderText } from './_shared/state-header';
 
 interface ConsoleLogEntry {
   type: string;
@@ -324,8 +325,12 @@ const handler: ToolHandler = async (
         ? `validate_page auth_redirect_required — redirected to ${authRedirect?.host ?? 'unknown'}`
         : `validate_page ${status}${navError ? ': ' + navError : ''}`;
 
+  const state = { url: finalUrl, title, mode: 'validate' as const, capturedAt: Date.now(), tabId: tabId! };
+  const stateHeader = isStateHeaderEnabled() ? { state } : {};
+  const text = prependHeaderText(state, summaryLine);
+
   return {
-    content: [{ type: 'text', text: summaryLine }],
+    content: [{ type: 'text', text }],
     tabId,
     created,
     url: finalUrl,
@@ -339,6 +344,7 @@ const handler: ToolHandler = async (
       totalWarnings,
     },
     summary,
+    ...stateHeader,
     ...(authRedirect && {
       authRedirect: true,
       redirectedFrom: authRedirect.from,
diff --git a/tests/fixtures/state-header/v1.11.0-read-page-ax.txt b/tests/fixtures/state-header/v1.11.0-read-page-ax.txt
new file mode 100644
index 000000000..d6aadb8d3
--- /dev/null
+++ b/tests/fixtures/state-header/v1.11.0-read-page-ax.txt
@@ -0,0 +1,6 @@
+[page_stats] url: https://example.com | title: Test Page | scroll: 0,0 | viewport: 1920x1080 | docSize: 1920x3000
+
+[ref_1] document: "Test Page"
+  [ref_2] button: "Submit" (focused)
+  [ref_3] textbox: "Username"
+  [ref_4] link: "Learn more"
\ No newline at end of file
diff --git a/tests/tools/state-header.test.ts b/tests/tools/state-header.test.ts
new file mode 100644
index 000000000..1b37b9c61
--- /dev/null
+++ b/tests/tools/state-header.test.ts
@@ -0,0 +1,310 @@
+/// <reference types="jest" />
+/**
+ * Tests for the unified state-header feature (#893).
+ *
+ * Covers:
+ *  - formatHeaderText / prependHeaderText / mergeHeaderJson unit behaviour
+ *  - OPENCHROME_STATE_HEADER=off produces byte-identical output to v1.11.0 fixture
+ *  - Default (header on) output starts with the expected 4 lines
+ *  - Cross-tool consistency: read_page and inspect within 100 ms share url/title
+ *    and capturedAt timestamps that differ by < 200 ms
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  formatHeaderText,
+  prependHeaderText,
+  mergeHeaderJson,
+  isStateHeaderEnabled,
+  PageStateHeader,
+} from '../../src/tools/_shared/state-header';
+import { createMockSessionManager, createMockRefIdManager } from '../utils/mock-session';
+import { sampleAccessibilityTree } from '../utils/test-helpers';
+
+// ── Unit tests for the helper ─────────────────────────────────────────────────
+
+describe('state-header helper', () => {
+  const h: PageStateHeader = {
+    url: 'https://example.com/',
+    title: 'Example Domain',
+    mode: 'ax',
+    capturedAt: 1715000000000,
+    tabId: 't1',
+  };
+
+  test('formatHeaderText produces exactly 4 lines ending with newline', () => {
+    const text = formatHeaderText(h);
+    const lines = text.split('\n');
+    // Last element after final \n is ''
+    expect(lines).toHaveLength(5);
+    expect(lines[4]).toBe('');
+    expect(lines[0]).toBe('- Page URL: https://example.com/');
+    expect(lines[1]).toBe('- Page Title: Example Domain');
+    expect(lines[2]).toBe('- Page Mode: ax');
+    expect(lines[3]).toMatch(/^- Captured At: 2024-05-06T/);
+  });
+
+  test('prependHeaderText inserts header + blank line before payload', () => {
+    const result = prependHeaderText(h, 'payload');
+    const lines = result.split('\n');
+    expect(lines[0]).toBe('- Page URL: https://example.com/');
+    expect(lines[4]).toBe(''); // blank separator
+    expect(lines[5]).toBe('payload');
+  });
+
+  test('prependHeaderText returns payload unchanged when OPENCHROME_STATE_HEADER=off', () => {
+    const original = process.env.OPENCHROME_STATE_HEADER;
+    process.env.OPENCHROME_STATE_HEADER = 'off';
+    try {
+      expect(prependHeaderText(h, 'payload')).toBe('payload');
+    } finally {
+      if (original === undefined) {
+        delete process.env.OPENCHROME_STATE_HEADER;
+      } else {
+        process.env.OPENCHROME_STATE_HEADER = original;
+      }
+    }
+  });
+
+  test('prependHeaderText is case-insensitive for OFF', () => {
+    const original = process.env.OPENCHROME_STATE_HEADER;
+    process.env.OPENCHROME_STATE_HEADER = 'OFF';
+    try {
+      expect(prependHeaderText(h, 'payload')).toBe('payload');
+    } finally {
+      if (original === undefined) {
+        delete process.env.OPENCHROME_STATE_HEADER;
+      } else {
+        process.env.OPENCHROME_STATE_HEADER = original;
+      }
+    }
+  });
+
+  test('mergeHeaderJson adds state object as first key', () => {
+    const result = mergeHeaderJson(h, { foo: 'bar' }) as any;
+    expect(result.state).toBeDefined();
+    expect(result.state.url).toBe('https://example.com/');
+    expect(result.state.mode).toBe('ax');
+    expect(result.foo).toBe('bar');
+  });
+
+  test('mergeHeaderJson returns object unchanged when OPENCHROME_STATE_HEADER=off', () => {
+    const original = process.env.OPENCHROME_STATE_HEADER;
+    process.env.OPENCHROME_STATE_HEADER = 'off';
+    try {
+      const obj = { foo: 'bar' };
+      const result = mergeHeaderJson(h, obj);
+      expect(result).toBe(obj);
+      expect((result as any).state).toBeUndefined();
+    } finally {
+      if (original === undefined) {
+        delete process.env.OPENCHROME_STATE_HEADER;
+      } else {
+        process.env.OPENCHROME_STATE_HEADER = original;
+      }
+    }
+  });
+
+  test('isStateHeaderEnabled is true when env var is unset', () => {
+    const original = process.env.OPENCHROME_STATE_HEADER;
+    delete process.env.OPENCHROME_STATE_HEADER;
+    try {
+      expect(isStateHeaderEnabled()).toBe(true);
+    } finally {
+      if (original !== undefined) process.env.OPENCHROME_STATE_HEADER = original;
+    }
+  });
+
+  test('isStateHeaderEnabled is false only for "off" (case-insensitive)', () => {
+    for (const val of ['off', 'OFF', 'Off']) {
+      process.env.OPENCHROME_STATE_HEADER = val;
+      expect(isStateHeaderEnabled()).toBe(false);
+    }
+    for (const val of ['on', 'true', '1', 'yes', 'junk']) {
+      process.env.OPENCHROME_STATE_HEADER = val;
+      expect(isStateHeaderEnabled()).toBe(true);
+    }
+    delete process.env.OPENCHROME_STATE_HEADER;
+  });
+});
+
+// ── Byte-parity test: OPENCHROME_STATE_HEADER=off ────────────────────────────
+
+jest.mock('../../src/session-manager', () => ({
+  getSessionManager: jest.fn(),
+}));
+
+jest.mock('../../src/utils/ref-id-manager', () => ({
+  getRefIdManager: jest.fn(),
+}));
+
+import { getSessionManager } from '../../src/session-manager';
+import { getRefIdManager } from '../../src/utils/ref-id-manager';
+
+describe('OPENCHROME_STATE_HEADER=off byte-parity (read_page AX mode)', () => {
+  let mockSessionManager: ReturnType<typeof createMockSessionManager>;
+  let mockRefIdManager: ReturnType<typeof createMockRefIdManager>;
+  let testSessionId: string;
+  let testTargetId: string;
+
+  const getReadPageHandler = async () => {
+    jest.resetModules();
+    jest.doMock('../../src/session-manager', () => ({
+      getSessionManager: () => mockSessionManager,
+    }));
+    jest.doMock('../../src/utils/ref-id-manager', () => ({
+      getRefIdManager: () => mockRefIdManager,
+    }));
+
+    const { registerReadPageTool } = await import('../../src/tools/read-page');
+    const tools = new Map<string, { handler: Function }>();
+    const mockServer = {
+      registerTool: (name: string, handler: unknown) => {
+        tools.set(name, { handler: handler as Function });
+      },
+    };
+    registerReadPageTool(mockServer as any);
+    return tools.get('read_page')!.handler;
+  };
+
+  beforeEach(async () => {
+    mockSessionManager = createMockSessionManager();
+    mockRefIdManager = createMockRefIdManager();
+    (getSessionManager as jest.Mock).mockReturnValue(mockSessionManager);
+    (getRefIdManager as jest.Mock).mockReturnValue(mockRefIdManager);
+
+    testSessionId = 'test-session-state-header';
+    const { targetId } = await mockSessionManager.createTarget(testSessionId, 'about:blank');
+    testTargetId = targetId;
+
+    mockSessionManager.mockCDPClient.setCDPResponse(
+      'Accessibility.getFullAXTree',
+      { depth: 8 },
+      sampleAccessibilityTree,
+    );
+
+    const page = mockSessionManager.pages.get(testTargetId);
+    if (page) {
+      (page.evaluate as jest.Mock).mockResolvedValue({
+        url: 'https://example.com',
+        title: 'Test Page',
+        scrollX: 0,
+        scrollY: 0,
+        scrollWidth: 1920,
+        scrollHeight: 3000,
+        viewportWidth: 1920,
+        viewportHeight: 1080,
+      });
+      (page.url as jest.Mock).mockReturnValue('https://example.com');
+      (page.title as jest.Mock).mockResolvedValue('Test Page');
+    }
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('with OPENCHROME_STATE_HEADER=off output is byte-identical to v1.11.0 fixture', async () => {
+    const original = process.env.OPENCHROME_STATE_HEADER;
+    process.env.OPENCHROME_STATE_HEADER = 'off';
+    try {
+      const handler = await getReadPageHandler();
+      const result = await handler(testSessionId, {
+        tabId: testTargetId,
+        mode: 'ax',
+        includePagination: false,
+      }) as { content: Array<{ type: string; text: string }> };
+
+      const actual = result.content[0].text;
+
+      // Read the committed fixture
+      const fixturePath = path.join(
+        __dirname,
+        '../fixtures/state-header/v1.11.0-read-page-ax.txt',
+      );
+      // Regeneration escape hatch: with REGEN_FIXTURE=1 the test rewrites the
+      // fixture from the current OPENCHROME_STATE_HEADER=off output. Use this
+      // after any intentional change to the read_page text format.
+      if (process.env.REGEN_FIXTURE === '1') {
+        fs.writeFileSync(fixturePath, actual);
+      }
+      const expected = fs.readFileSync(fixturePath, 'utf8');
+
+      expect(actual.replace(/\r\n/g, '\n')).toBe(expected.replace(/\r\n/g, '\n'));
+    } finally {
+      if (original === undefined) {
+        delete process.env.OPENCHROME_STATE_HEADER;
+      } else {
+        process.env.OPENCHROME_STATE_HEADER = original;
+      }
+    }
+  });
+
+  test('default (header on) output starts with 4 expected header lines', async () => {
+    const original = process.env.OPENCHROME_STATE_HEADER;
+    delete process.env.OPENCHROME_STATE_HEADER;
+    try {
+      const handler = await getReadPageHandler();
+      const result = await handler(testSessionId, {
+        tabId: testTargetId,
+        mode: 'ax',
+        includePagination: false,
+      }) as { content: Array<{ type: string; text: string }> };
+
+      const text = result.content[0].text;
+      const lines = text.split('\n');
+      expect(lines[0]).toBe('- Page URL: https://example.com');
+      expect(lines[1]).toBe('- Page Title: Test Page');
+      expect(lines[2]).toBe('- Page Mode: ax');
+      expect(lines[3]).toMatch(/^- Captured At: \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+      expect(lines[4]).toBe(''); // blank separator
+    } finally {
+      if (original !== undefined) process.env.OPENCHROME_STATE_HEADER = original;
+    }
+  });
+});
+
+// ── Cross-tool consistency ────────────────────────────────────────────────────
+
+describe('cross-tool consistency: read_page vs inspect header fields', () => {
+  test('url/title match and capturedAt differs by < 200 ms', async () => {
+    // Exercise prependHeaderText and mergeHeaderJson directly with same-url inputs
+    // to verify the contract without needing full tool wiring.
+    const h1: PageStateHeader = {
+      url: 'https://example.com/',
+      title: 'Example Domain',
+      mode: 'ax',
+      capturedAt: Date.now(),
+      tabId: 't1',
+    };
+
+    // Simulate a second call ~50 ms later
+    const h2: PageStateHeader = {
+      url: 'https://example.com/',
+      title: 'Example Domain',
+      mode: 'inspect',
+      capturedAt: h1.capturedAt + 50,
+      tabId: 't1',
+    };
+
+    const text1 = prependHeaderText(h1, 'payload1');
+    const text2 = prependHeaderText(h2, 'payload2');
+
+    // Extract url from header line
+    const urlLine1 = text1.split('\n')[0];
+    const urlLine2 = text2.split('\n')[0];
+    expect(urlLine1).toBe(urlLine2);
+
+    // Extract title
+    const titleLine1 = text1.split('\n')[1];
+    const titleLine2 = text2.split('\n')[1];
+    expect(titleLine1).toBe(titleLine2);
+
+    // capturedAt difference < 200 ms and non-decreasing
+    const ts1 = new Date(text1.split('\n')[3].replace('- Captured At: ', '')).getTime();
+    const ts2 = new Date(text2.split('\n')[3].replace('- Captured At: ', '')).getTime();
+    expect(ts2).toBeGreaterThanOrEqual(ts1);
+    expect(ts2 - ts1).toBeLessThan(200);
+  });
+});