diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6957c9c..9cda977 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,62 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.19.4] - 2025-10-13
+
+### 🐛 Critical Bug Fixes
+
+**MCP Server Initialization for Restored Sessions (P0 - CRITICAL)**
+
+Completes the session restoration feature by initializing MCP server instances for restored sessions, enabling tool calls to work after server restart.
+
+#### Fixed
+
+- **MCP Server Not Initialized During Session Restoration**
+  - **Issue**: Session restoration successfully restored InstanceContext (v2.19.0) and transport layer (v2.19.3), but failed to initialize the MCP Server instance, causing all tool calls on restored sessions to fail with "Server not initialized" error
+  - **Impact**: Zero-downtime deployments still broken - users cannot use tools after container restart without manually restarting their MCP client
+  - **Severity**: CRITICAL - session persistence incomplete without MCP server initialization
+  - **Root Cause**:
+    - MCP protocol requires an `initialize` handshake before accepting tool calls
+    - When restoring a session, we create a NEW MCP Server instance (uninitialized state)
+    - Client thinks it already initialized (it did, with the old instance before restart)
+    - Client sends tool call, new server rejects it: "Server not initialized"
+    - The three layers of a session: (1) Data (InstanceContext) ✅, (2) Transport (HTTP) ✅ v2.19.3, (3) Protocol (MCP Server) ❌ not initialized
+  - **Fix Applied**:
+    - Created `initializeMCPServerForSession()` method that sends synthetic initialize request to new MCP server instance
+    - Brings server into initialized state without requiring client to re-initialize
+    - Called after `server.connect(transport)` during session restoration flow
+    - Includes 5-second timeout and comprehensive error handling
+  - **Location**: `src/http-server-single-session.ts:521-605` (new method), `src/http-server-single-session.ts:1321-1327` (application)
+  - **Tests**: Compilation verified, ready for integration testing
+  - **Verification**: Build successful, no TypeScript errors
+
+#### Technical Details
+
+**The Three Layers of Session State:**
+1. **Data Layer** (InstanceContext): Session configuration and state ✅ v2.19.0
+2. **Transport Layer** (HTTP Connection): Request/response binding ✅ v2.19.3
+3. **Protocol Layer** (MCP Server Instance): Initialize handshake ✅ v2.19.4
+
+**Implementation:**
+```typescript
+// After connecting transport, initialize the MCP server
+await server.connect(transport);
+await this.initializeMCPServerForSession(sessionId, server, restoredContext);
+```
+
+The synthetic initialize request:
+- Uses standard MCP protocol version
+- Includes client info: `n8n-mcp-restored-session`
+- Calls server's initialize handler directly
+- Waits for initialization to complete (5 second timeout)
+- Brings server into initialized state
+
+#### Dependencies
+
+- Requires: v2.19.3 (transport layer fix)
+- Completes: Session persistence feature (v2.19.0-v2.19.4)
+- Enables: True zero-downtime deployments for HTTP-based deployments
+
 ## [2.19.3] - 2025-10-13
 
 ### 🐛 Critical Bug Fixes
diff --git a/package.json b/package.json
index 5f354dd..bcc1ea8 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "n8n-mcp",
-  "version": "2.19.3",
+  "version": "2.19.4",
   "description": "Integration between n8n workflow automation and Model Context Protocol (MCP)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
diff --git a/package.runtime.json b/package.runtime.json
index a26b235..68121e8 100644
--- a/package.runtime.json
+++ b/package.runtime.json
@@ -1,6 +1,6 @@
 {
   "name": "n8n-mcp-runtime",
-  "version": "2.19.3",
+  "version": "2.19.4",
   "description": "n8n MCP Server Runtime Dependencies Only",
   "private": true,
   "main": "dist/index.js",
diff --git a/src/http-server-single-session.ts b/src/http-server-single-session.ts
index 949818f..433c533 100644
--- a/src/http-server-single-session.ts
+++ b/src/http-server-single-session.ts
@@ -18,7 +18,7 @@ import { getStartupBaseUrl, formatEndpointUrls, detectBaseUrl } from './utils/ur
 import { PROJECT_VERSION } from './utils/version';
 import { v4 as uuidv4 } from 'uuid';
 import { createHash } from 'crypto';
-import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import { isInitializeRequest, InitializeRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import {
   negotiateProtocolVersion,
   logProtocolNegotiation,
@@ -518,6 +518,92 @@ export class SingleSessionHTTPServer {
     }
   }
 
+  /**
+   * Initialize MCP server for a restored session (v2.19.4)
+   *
+   * When restoring a session, we create a new MCP Server instance, but the client
+   * thinks it already initialized (it did, with the old instance before restart).
+   * This method sends a synthetic initialize request to bring the new server
+   * instance into initialized state, enabling it to handle tool calls.
+   *
+   * @param sessionId - Session ID being restored
+   * @param server - The N8NDocumentationMCPServer instance to initialize
+   * @param instanceContext - Instance configuration
+   * @throws Error if initialization fails or times out
+   * @since 2.19.4
+   */
+  private async initializeMCPServerForSession(
+    sessionId: string,
+    server: N8NDocumentationMCPServer,
+    instanceContext?: InstanceContext
+  ): Promise<void> {
+    const initStartTime = Date.now();
+    const initTimeout = 5000; // 5 seconds max for initialization
+
+    try {
+      logger.info('Initializing MCP server for restored session', {
+        sessionId,
+        instanceId: instanceContext?.instanceId
+      });
+
+      // Create synthetic initialize request matching MCP protocol spec
+      const initializeRequest = {
+        jsonrpc: '2.0' as const,
+        id: `init-${sessionId}`,
+        method: 'initialize',
+        params: {
+          protocolVersion: STANDARD_PROTOCOL_VERSION,
+          capabilities: {
+            // Client capabilities - basic tool support
+            tools: {}
+          },
+          clientInfo: {
+            name: 'n8n-mcp-restored-session',
+            version: PROJECT_VERSION
+          }
+        }
+      };
+
+      // Call the server's initialize handler directly
+      // The server was already created with setupHandlers() in constructor
+      // So the initialize handler is registered and ready
+      const initPromise = (server as any).server.request(initializeRequest, InitializeRequestSchema);
+
+      // Race against timeout
+      const timeoutPromise = this.timeout(initTimeout);
+
+      const response = await Promise.race([initPromise, timeoutPromise]);
+
+      const duration = Date.now() - initStartTime;
+
+      logger.info('MCP server initialized successfully for restored session', {
+        sessionId,
+        duration: `${duration}ms`,
+        protocolVersion: response.protocolVersion
+      });
+
+    } catch (error) {
+      const duration = Date.now() - initStartTime;
+
+      if (error instanceof Error && error.name === 'TimeoutError') {
+        logger.error('MCP server initialization timeout for restored session', {
+          sessionId,
+          timeout: initTimeout,
+          duration: `${duration}ms`
+        });
+        throw new Error(`MCP server initialization timeout after ${initTimeout}ms`);
+      }
+
+      logger.error('MCP server initialization failed for restored session', {
+        sessionId,
+        error: error instanceof Error ? error.message : String(error),
+        duration: `${duration}ms`
+      });
+
+      throw new Error(`MCP server initialization failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
   /**
    * Restore session with retry policy (Phase 4 - REQ-7)
    *
@@ -1232,6 +1318,14 @@ export class SingleSessionHTTPServer {
                 logger.info('Connecting server to restored session transport');
                 await server.connect(transport);
 
+                // CRITICAL FIX v2.19.4: Initialize MCP server for restored session
+                // The MCP protocol requires an initialize handshake before tool calls.
+                // Since the client already initialized with the old server instance
+                // (before restart), we need to synthetically initialize the new server
+                // instance to bring it into the initialized state.
+                logger.info('Initializing MCP server for restored session', { sessionId });
+                await this.initializeMCPServerForSession(sessionId, server, restoredContext);
+
                 // Phase 3: Emit onSessionRestored event (REQ-4)
                 // Fire-and-forget: don't await or block request processing
                 this.emitEvent('onSessionRestored', sessionId, restoredContext).catch(err => {
diff --git a/src/mcp-engine.ts b/src/mcp-engine.ts
index 2f45c2f..a519276 100644
--- a/src/mcp-engine.ts
+++ b/src/mcp-engine.ts
@@ -163,7 +163,7 @@ export class N8NMCPEngine {
           total: Math.round(memoryUsage.heapTotal / 1024 / 1024),
           unit: 'MB'
         },
-        version: '2.19.3'
+        version: '2.19.4'
       };
     } catch (error) {
       logger.error('Health check failed:', error);
@@ -172,7 +172,7 @@ export class N8NMCPEngine {
         uptime: 0,
         sessionActive: false,
         memoryUsage: { used: 0, total: 0, unit: 'MB' },
-        version: '2.19.3'
+        version: '2.19.4'
       };
     }
   }