Okay, I need to create a single-page Windows 95 style desktop. Let's start by planning the structure. The user wants everything in one index.html file with inline CSS and JS, no external resources.

First, the HTML structure. There should be a desktop area, a taskbar at the bottom, a Start button, desktop icons, and draggable windows. Each window needs to be closable. The clock should be part of the taskbar.

For the desktop icons, I'll use divs with images and labels. Maybe use Windows 95 style icons. Since I can't use external images, I'll need to use base64 encoded icons. But wait, the user said no network requests, so all resources must be inline. So I'll create simple SVG icons for My Computer, Recycle Bin, etc., using base64 or inline SVG.

Wait, base64 might be too long, but maybe for simplicity, use very basic SVGs. Alternatively, use Unicode symbols, but Windows 95 icons are specific. Maybe use small inline SVGs. For example, the Recycle Bin could be a simple SVG trash can.

The taskbar should have the Start button on the left, then open windows, and the clock on the right. The Start button needs a dropdown menu when clicked.

Draggable windows: each window is a div with a title bar, content, and close button. Using JS to handle dragging by tracking mouse events. Need to manage z-index so the active window is on top.

Closable windows: each window has an 'X' button that removes the window from the DOM.

The clock should update every second. Use JavaScript setInterval to update the time display.

Let me outline the HTML structure:

- A div for the desktop (background color, maybe a pattern)
- Desktop icons: divs with class 'icon', each containing an img (or SVG) and a label
- Taskbar div at the bottom with Start button, taskbar buttons for open windows, and clock
- Windows: each is a div with class 'window', containing title bar, content, close button

CSS should position the desktop as relative, icons absolute with positions, taskbar fixed at bottom.

JS for:
- Dragging windows (mousedown on title bar, track mousemove, update position)
- Closing windows (click X removes the window)
- Start menu toggle (click Start shows/hides menu)
- Clock update

Let me start writing the HTML. Need to inline all CSS in a style tag and JS in a script tag.

First, set up the basic HTML structure with doctype, html, head, body.

In head: title "Windows 95 Desktop", style tag with all CSS.

In body: desktop div, taskbar div.

Desktop icons: create several divs with positions. For example:

<div class="icon" style="top: 50px; left: 50px;">
  <div class="icon-image">[SVG]</div>
  <div class="icon-label">My Computer</div>
</div>

Taskbar: 

<div id="taskbar">
  <div id="start-button">Start</div>
  <div id="taskbar-buttons"></div>
  <div id="clock"></div>
</div>

Windows: each window is a div with id like "window1", class "window", with style for position.

JS needs to handle:
- Start button click: toggle start menu (a div that appears when clicked)
- Dragging: when mousedown on .window-title, record offset, on mousemove update position
- Close button: when clicked, remove the window
- Clock: set interval to update time

Wait, the start menu should be a dropdown with items like Programs, Settings, etc. So need a hidden div that shows when Start is clicked.

Let me sketch the CSS:

body { margin: 0; overflow: hidden; }
#desktop { position: relative; width: 100vw; height: calc(100vh - 30px); background: #008080; /* Windows 95 blue */ }
.icon { position: absolute; text-align: center; width: 60px; }
.icon-image { width: 32px; height: 32px; background: #ccc; margin: 0 auto; }
.icon-label { color: white; text-shadow: 1px 1px black; }

#taskbar { position: fixed; bottom: 0; width: 100%; height: 30px; background: #c0c0c0; display: flex; }
#start-button { width: 60px; background: #000080; color: white; text-align: center; line-height: 30px; }
#clock { padding: 0 10px; line-height: 30px; }

.window { position: absolute; border: 2px solid #000; background: #c0c0c0; }
.window-title { background: #000080; color: white; padding: 2px; cursor: move; }
.window-content { padding: 5px; }
.window-close { float: right; cursor: pointer; }

.start-menu { display: none; position: absolute; bottom: 30px; left: 0; background: #c0c0c0; border: 1px solid black; }

Now JS:

- When Start button is clicked, toggle start menu display.
- For each window, handle close button click to remove the window.
- Dragging: on mousedown of .window-title, set a flag, record mouse position and window position. On mousemove, if dragging, update window position. On mouseup, stop dragging.
- Clock: every second, update the clock element with current time.

Need to manage z-index for active window. When a window is clicked, bring it to front by increasing z-index.

Let me think about the JS code structure.

Variables:
- let dragging = null; // holds the window being dragged
- let offsetX, offsetY; // mouse offset from window top-left

Functions:
- initDrag(windowElement)
- updateClock()

For each window, add event listeners to title bar for mousedown, which sets dragging = windowElement, records offset.

In mousemove, if dragging, update left and top style.

Start button click: toggle start menu visibility.

Close button click: remove the window from DOM.

Also, when a window is clicked, bring it to front (set z-index higher than others).

Now, putting it all together in a single HTML file.

Need to make sure all elements are created in the HTML or generated via JS. Since it's a static page, maybe create some default windows and icons in HTML, but the user might want to open new windows from Start menu. Wait, the problem says "recreate Windows 95 style", so maybe have a few default windows.

Wait, the user didn't specify if the Start menu should have options that open windows, but to keep it simple, maybe the Start button just shows a menu, and clicking an item opens a sample window.

But the problem says "working clock" and "draggable and closable windows", so perhaps the minimal requirement is having at least one window that can be dragged and closed.

Let me outline the steps:

1. Create the desktop structure with icons, taskbar, and a sample window.
2. Style everything to look like Windows 95 (colors, borders).
3. Implement JS for dragging, closing, start menu, and clock.

Let's start coding.

First, the HTML structure:

<!DOCTYPE html>
<html>
<head>
  <title>Windows 95 Desktop</title>
  <style>
    /* CSS here */
  </style>
</head>
<body>
  <div id="desktop">
    <!-- Desktop icons -->
    <div class="icon" style="top: 50px; left: 50px;">
      <div class="icon-image">🖥️</div>
      <div class="icon-label">My Computer</div>
    </div>
    <div class="icon" style="top: 50px; left: 120px;">
      <div class="icon-image">🗑️</div>
      <div class="icon-label">Recycle Bin</div>
    </div>
  </div>
  <div id="taskbar">
    <div id="start-button">Start</div>
    <div id="taskbar-buttons"></div>
    <div id="clock"></div>
  </div>
  <div id="start-menu" class="start-menu">
    <div>Programs</div>
    <div>Settings</div>
    <div>Help</div>
    <div>Run...</div>
    <div>Shut Down</div>
  </div>
  <div class="window" id="window1" style="left: 100px; top: 100px; width: 300px; height: 200px;">
    <div class="window-title">My Computer
      <span class="window-close">×</span>
    </div>
    <div class="window-content">This is my computer window.</div>
  </div>
  <script>
    // JS here
  </script>
</body>
</html>

Now, CSS:

body {
  margin: 0;
  overflow: hidden;
  font-family: Arial, sans-serif;
}
#desktop {
  position: relative;
  width: 100vw;
  height: calc(100vh - 30px);
  background-color: #008080;
}
.icon {
  position: absolute;
  width: 60px;
  text-align: center;
  color: white;
  cursor: default;
}
.icon-image {
  width: 32px;
  height: 32px;
  margin: 0 auto;
  background-color: #c0c0c0;
  border: 1px solid #000;
  display: flex;
  align-items: center;
  justify-content: center;
}
.icon-label {
  text-shadow: 1px 1px 0 #000;
}
#taskbar {
  position: fixed;
  bottom: 0;
  width: 100%;
  height: 30px;
  background-color: #c0c0c0;
  display: flex;
  align-items: center;
  border-top: 2px solid #808080;
}
#start-button {
  width: 60px;
  background-color: #000080;
  color: white;
  text-align: center;
  height: 100%;
  line-height: 30px;
  cursor: pointer;
}
#clock {
  margin-left: auto;
  padding: 0 10px;
}
.start-menu {
  display: none;
  position: absolute;
  bottom: 30px;
  left: 0;
  background-color: #c0c0c0;
  border: 2px solid #000;
  width: 150px;
  z-index: 1000;
}
.start-menu div {
  padding: 5px;
  cursor: pointer;
}
.start-menu div:hover {
  background-color: #000080;
  color: white;
}
.window {
  border: 2px solid #000;
  background-color: #c0c0c0;
  box-shadow: 2px 2px 0 #808080;
}
.window-title {
  background-color: #000080;
  color: white;
  padding: 2px 5px;
  cursor: move;
  font-weight: bold;
}
.window-close {
  float: right;
  cursor: pointer;
  margin-left: 5px;
}
.window-content {
  padding: 5px;
}

Now JS:

Need to handle:
- Start button click to toggle menu
- Close window when X is clicked
- Dragging windows
- Clock update
- Bringing window to front on click

Let's write the JS.

First, variables:

let dragging = null;
let offsetX, offsetY;
let zIndex = 100;

function bringToFront(windowElement) {
  windowElement.style.zIndex = zIndex++;
}

document.getElementById('start-button').addEventListener('click', function() {
  const menu = document.getElementById('start-menu');
  menu.style.display = menu.style.display === 'block' ? 'none' : 'block';
});

document.querySelectorAll('.window-close').forEach(button => {
  button.addEventListener('click', function(e) {
    e.stopPropagation();
    this.closest('.window').remove();
  });
});

// Dragging functionality
document.addEventListener('mousedown', function(e) {
  const titleBar = e.target.closest('.window-title');
  if (titleBar) {
    dragging = titleBar.parentElement;
    offsetX = e.clientX - dragging.getBoundingClientRect().left;
    offsetY = e.clientY - dragging.getBoundingClientRect().top;
    bringToFront(dragging);
  }
});

document.addEventListener('mousemove', function(e) {
  if (dragging) {
    dragging.style.left = (e.clientX - offsetX) + 'px';
    dragging.style.top = (e.clientY - offsetY) + 'px';
  }
});

document.addEventListener('mouseup', function() {
  dragging = null;
});

// Clock
function updateClock() {
  const now = new Date();
  let hours = now.getHours();
  let minutes = now.getMinutes();
  let seconds = now.getSeconds();
  minutes = minutes < 10 ? '0' + minutes : minutes;
  seconds = seconds < 10 ? '0' + seconds : seconds;
  document.getElementById('clock').textContent = `${hours}:${minutes}:${seconds}`;
}
setInterval(updateClock, 1000);
updateClock();

// Click on window brings to front
document.addEventListener('click', function(e) {
  const windowEl = e.target.closest('.window');
  if (windowEl && windowEl !== dragging) {
    bringToFront(windowEl);
  }
});

Wait, the initial window is created in HTML, but if we add more windows via Start menu, we need a way to create them. However, the problem doesn't specify having a Start menu that opens new windows, but to keep it minimal, maybe the sample window is enough. But to make it more like Windows 95, clicking Programs in Start menu could open a window.

Let me adjust the Start menu to have a Programs option that opens a new window.

Add event listener to Start menu items:

document.getElementById('start-menu').addEventListener('click', function(e) {
  if (e.target.tagName === 'DIV') {
    if (e.target.textContent === 'Programs') {
      openWindow('Notepad', 'Edit your text here...');
    }
    // other options
  }
});

function openWindow(title, content) {
  const window = document.createElement('div');
  window.className = 'window';
  window.style.left = '150px';
  window.style.top = '150px';
  window.style.width = '300px';
  window.style.height = '200px';
  window.innerHTML = `
    <div class="window-title">${title}
      <span class="window-close">×</span>
    </div>
    <div class="window-content">${content}</div>
  `;
  document.body.appendChild(window);
  // Add close button event
  window.querySelector('.window-close').addEventListener('click', function(e) {
    e.stopPropagation();
    window.remove();
  });
  // Make draggable
  window.querySelector('.window-title').addEventListener('mousedown', function(e) {
    dragging = window;
    offsetX = e.clientX - window.getBoundingClientRect().left;
    offsetY = e.clientY - window.getBoundingClientRect().top;
    bringToFront(window);
  });
}

But since we're writing everything inline, need to include this function in the JS.

However, the problem says "recreate a Windows 95 style desktop", so having a few default windows and the ability to open more via Start menu would be good.

But the user didn't specify, so maybe the minimal version with one window is acceptable. However, to make it more complete, adding a Start menu option to open a window would be better.

Let me integrate that into the JS.

Also, need to handle the Start menu closing when clicking elsewhere. Add a click event to document to hide the menu if clicked outside.

document.addEventListener('click', function(e) {
  if (!e.target.closest('#start-button') && !e.target.closest('.start-menu')) {
    document.getElementById('start-menu').style.display = 'none';
  }
});

Now, putting all together.

Wait, the initial HTML has a window1 div. The JS needs to make it draggable and closable. The current JS code uses querySelectorAll for .window-close, but the initial window's close button is added after the JS runs? No, because the JS is at the end of the body, so the elements are present.

Wait, in the HTML, the window is created before the script, so when the JS runs, the elements exist. So the event listeners for close buttons will work.

Testing the code structure:

- The desktop has icons, taskbar, start menu, and a window.
- CSS styles everything to look like Windows 95.
- JS handles dragging, closing, start menu, clock.

Potential issues:

- The window's initial position uses inline styles (left and top). When dragging, the JS updates the style.left and style.top, which will override the initial inline styles. That's okay.

- The z-index management: when a window is clicked, it gets a higher z-index. The initial zIndex starts at 100, and each time a window is brought to front, zIndex increments.

- The Start menu appears when Start is clicked, and hides when clicking elsewhere.

- The clock updates every second.

Now, check if all elements are present and functional.

Need to make sure the Recycle Bin icon has a different image. Using emojis might not look like Windows 95, but since we can't use external images, emojis are a quick solution. Alternatively, use simple SVGs inline.

For example, the Recycle Bin icon could be:

<svg width="32" height="32" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
  <path d="M3 6h18v2H3V6zm9 9v-6m-3 3l3-3 3 3" stroke="black" stroke-width="2"/>
</svg>

But embedding SVG directly in the icon-image div.

So replace the emoji with SVG for better Windows 95 feel.

Similarly, My Computer could have a monitor SVG.

Let me adjust the icons:

For My Computer:

<div class="icon-image">
  <svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 24 24" fill="none" stroke="black" stroke-width="1">
    <rect x="2" y="7" width="20" height="12" rx="1"/>
    <line x1="6" y1="12" x2="18" y2="12"/>
    <line x1="12" y1="16" x2="12" y2="19"/>
  </svg>
</div>

Recycle Bin:

<div class="icon-image">
  <svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" viewBox="0 0 24 24" fill="none" stroke="black" stroke-width="1">
    <path d="M3 6h18v2H3V6zm9 9v-6m-3 3l3-3 3 3"/>
  </svg>
</div>

These are simplified SVGs that resemble the icons.

Now, putting all into the HTML file.

Need to ensure that the entire code is in one index.html file, with CSS in style tag and JS in script tag.

Let me write the complete index.html content.

Okay, let me check what the user asked for. They wanted a single-page Windows 95 style desktop with draggable and closable windows, a Start button, taskbar, desktop icons, and a working clock. All in one index.html file with inline CSS and JS, no external resources.

I created the index.html file using the write tool. The file includes:

- HTML structure with desktop, taskbar, start menu, and a sample window.
- CSS in a style tag to mimic Windows 95's look: blue background, gray taskbar, window styles.
- SVG icons for My Computer and Recycle Bin inline to avoid external resources.
- JavaScript for dragging windows, closing them, start menu toggle, and clock.

I made sure everything is self-contained. The JS handles:
- Dragging by tracking mouse events.
- Closing windows via the '×' button.
- Start menu that appears when clicked and hides elsewhere.
- Clock updating every second.
- Bringing windows to front on click.

Checked that no external resources are used. SVGs are inline, all code is in one file. Tested the structure for correctness. The user should be able to open index.html and see the Windows 95 desktop simulation working as described.