@@ -55,13 +55,16 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        # Windows validation is temporarily paused until its checks are reliable.
-        os: [ubuntu-latest, macos-latest]
+        # Windows runs a focused contract; full capability coverage remains on Linux/macOS.
+        os: [ubuntu-latest, macos-latest, windows-latest]
         node: ["24"]
         include:
           - os: ubuntu-latest
             node: "24"
             profile: full
+          - os: windows-latest
+            node: "24"
+            profile: windows
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
 
@@ -37,13 +37,13 @@ pnpm install --frozen-lockfile
 pnpm verify
 ```
 
-`pnpm verify` runs the complete gate list in the same order as GitHub CI. Normal PR and main-branch checks use Node.js 24 on Linux and macOS. Windows CI is temporarily paused while its checks are made reliable. The Linux job runs this full profile; the macOS job uses `pnpm verify --profile platform`, which omits only the duplicate TypeScript compiler check. Both jobs still export source, build, and test their own platform artifacts. Gates that depend on platform behaviour are selected by platform rather than skipped silently; run `pnpm verify --list` or `pnpm verify --profile platform --list` to inspect either plan. Individual gates remain available as their own scripts, such as `pnpm typecheck` or `pnpm test:byok`, while you iterate.
+`pnpm verify` runs the complete gate list in the same order as GitHub CI. Normal PR and main-branch checks use Node.js 24 on Linux and macOS. The Linux job runs the full profile; the macOS job uses `pnpm verify --profile platform`, which omits only the duplicate TypeScript compiler check. Windows runs the focused `pnpm verify --profile windows` contract on PRs; the profile is Windows-only and fails closed elsewhere. It checks source inventory, release tooling, build boundaries, artifacts, and Windows-specific tests without running the full capability suite. Gates that depend on platform behaviour are selected by platform rather than skipped silently; run `pnpm verify --list`, `pnpm verify --profile platform --list`, or `pnpm verify --profile windows --list` to inspect each plan. Individual gates remain available as their own scripts, such as `pnpm typecheck` or `pnpm test:byok`, while you iterate.
 
 CI writes per-gate timing and exit metadata to the Job Summary and a seven-day `verification-<os>-node-<version>-<attempt>` artifact. For a local report, set `MCODE_VERIFY_REPORT_DIR` to a directory outside the repository. Reports distinguish `PASS`, `FAIL`, intentional `SKIP`, and `NOT_RUN` after a failure. JSON is checkpointed before and after each gate; a cancelled run may leave `RUNNING`, which is not a pass. If installation fails before verification starts, no verification report is available. Reports do not collect command output, environment variables, or runtime data; read the corresponding gate's job log for failure details, including the existing bounded BYOK timeout diagnostics. CI jobs have a 15-minute verification limit and a 10-minute release-audit limit.
 
 Existing README files, `CONTRIBUTING.md`, `.github/PULL_REQUEST_TEMPLATE.md`, Markdown under `docs/`, and media directly under `docs/assets/` use the `docs` profile when they are the only changed paths. That profile checks the source inventory and generated paths, exports the committed source, and tests release tooling. History and source-snapshot secret scans still run; platform builds and distribution scans are skipped. Mixed changes, unknown paths, missing comparisons, and any `release/` inventory change get full CI. Documentation-only changes skip the platform matrix entirely. The `verification` aggregate check always runs and rejects failed, cancelled, or unexpectedly skipped jobs. Use it together with `source-history-artifact` as required checks when configuring branch protection; this repository's automation does not change administrative settings.
 
-`Node compatibility` runs weekly and on demand against macOS and Linux with Node 22.19.0, 24.2.0, 25 and 26. Windows is also temporarily excluded from this matrix. It does not run automatically on PRs. Dispatch it on the selected branch for changes to supported Node versions, native dependencies or compatibility-sensitive verification tooling, and before a source release. This covers the minimum versions of the two supported ranges and the additional supported majors. Deferring those versions from ordinary PR checks can delay regression discovery; a known failure in a supported version still needs resolution before release. Dependabot proposes weekly Actions and npm updates, grouping Actions and development-tool minor/patch updates. External Actions use reviewed full commit SHAs, while local actions and reusable workflows come from the same checked-out revision.
+`Node compatibility` runs weekly and on demand against macOS and Linux with Node 22.19.0, 24.2.0, 25 and 26. Windows remains excluded from this matrix; the PR Windows contract is a focused Node 24 check, not a substitute for the full compatibility matrix. It does not run automatically on PRs. Dispatch it on the selected branch for changes to supported Node versions, native dependencies or compatibility-sensitive verification tooling, and before a source release. This covers the minimum versions of the two supported ranges and the additional supported majors. Deferring those versions from ordinary PR checks can delay regression discovery; a known failure in a supported version still needs resolution before release. Dependabot proposes weekly Actions and npm updates, grouping Actions and development-tool minor/patch updates. External Actions use reviewed full commit SHAs, while local actions and reusable workflows come from the same checked-out revision.
 
 Source candidates are requested independently through the `Source candidate` workflow; ordinary PRs and main pushes do not produce them. Its Linux/macOS archive validation is described in [Releasing](docs/releasing.md). `CLI release` builds npm-installable tar.gz packages from version tags and validates the same archive before attaching it to a GitHub Release. Its `package` verification profile tests installation of an existing archive; it does not replace full source verification. npm registry and official installer publication remain separate release processes.
 
 
@@ -87,7 +87,7 @@ Before npm or installer distribution, separately validate the published package
 
 The `Source candidate` workflow exports the selected commit without Git history, verifies its receipt, and scans both repository history and the extracted source. Linux and macOS runners authenticate the same archive, install from public npm into fresh stores, and run the archive verification profile.
 
-Windows validation is temporarily paused across source verification, Node compatibility, and source candidates. Candidate reports cover only Linux and macOS; a successful candidate does not establish Windows acceptance. Restore the Windows workflow matrices and the required report set in `scripts/source-candidate.mjs` together when Windows checks are reliable again.
+Windows full validation is temporarily paused for Node compatibility and source candidates. Ordinary pull requests run a focused Windows source-verification contract, but candidate reports still cover only Linux and macOS; a successful candidate does not establish Windows acceptance. Restore the Windows compatibility/source-candidate matrices and the required report set in `scripts/source-candidate.mjs` together when those checks are reliable again.
 
 After both platform jobs pass, the workflow creates a `source-candidate-<full-SHA>` artifact containing:
 
 
@@ -25,6 +25,7 @@
     "test:status-contract": "node scripts/run-vitest-suite.mjs status-contract",
     "check:source": "node scripts/source-inventory.mjs",
     "test:capabilities": "node scripts/run-vitest-suite.mjs capability",
+    "test:windows": "node scripts/run-vitest-suite.mjs windows",
     "test:artifact": "node --test test/public-artifact.test.mjs",
     "test:release-tools": "node --test test/source-sync.test.mjs"
   },
 
@@ -27,15 +27,18 @@ export function checkWindowsSourceLocation({
   if (!/^[a-z]:\\$/iu.test(root) || root.startsWith("\\\\")) {
     return fail("The checkout root is not a local drive-letter path.");
   }
+  // `fsutil` accepts a drive letter more reliably than a root path with a
+  // trailing backslash across Windows runner images.
+  const volume = root.slice(0, 2);
 
   let driveType;
   let volumeInfo;
   try {
-    driveType = execFile("fsutil", ["fsinfo", "drivetype", root], {
+    driveType = execFile("fsutil", ["fsinfo", "drivetype", volume], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
     });
-    volumeInfo = execFile("fsutil", ["fsinfo", "volumeinfo", root], {
+    volumeInfo = execFile("fsutil", ["fsinfo", "volumeinfo", volume], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
     });
 
@@ -25,8 +25,10 @@ const { values } = parseArgs({
   },
 });
 const profile = values.profile;
-if (!["full", "platform", "docs", "archive", "package"].includes(profile))
+if (!["full", "platform", "windows", "docs", "archive", "package"].includes(profile))
   throw new Error(`Unknown verification profile: ${profile}`);
+if (profile === "windows" && process.platform !== "win32")
+  throw new Error("Windows verification profile requires a Windows host");
 if (profile === 'package' && !['darwin', 'linux'].includes(process.platform))
   throw new Error('Package verification currently supports Linux and macOS only.');
 // Listing must not leave a temporary export directory behind.
@@ -36,22 +38,24 @@ const temporary = values.list
 const preview = path.join(temporary ?? tmpdir(), "minimax-code-source.tar.gz");
 
 const steps = [
-  { name: "check:source", script: "check:source", docs: true },
-  { name: "check:tsconfig", script: "check:tsconfig", docs: true },
+  { name: "check:source", script: "check:source", docs: true, windows: true },
+  { name: "check:tsconfig", script: "check:tsconfig", docs: true, windows: true },
   {
     name: "export source preview",
     docs: true,
+    windows: true,
     requiresGit: true,
     command: ["scripts/export-source-preview.mjs", "--out", preview],
   },
-  { name: "test:release-tools", script: "test:release-tools", docs: true },
+  { name: "test:release-tools", script: "test:release-tools", docs: true, windows: true },
   // Compiler inputs are identical across the matrix. One Linux job runs this;
   // all platforms still build and validate native artifacts on their own platform.
   { name: "typecheck", script: "typecheck", fullOnly: true },
-  { name: "build", script: "build" },
-  { name: "check:standalone", script: "check:standalone" },
-  { name: "test:artifact", script: "test:artifact" },
+  { name: "build", script: "build", windows: true },
+  { name: "check:standalone", script: "check:standalone", windows: true },
+  { name: "test:artifact", script: "test:artifact", windows: true },
   { name: "test:capabilities", script: "test:capabilities" },
+  { name: "test:windows", script: "test:windows", platforms: ["win32"], windows: true },
   { name: "test:status-contract", script: "test:status-contract" },
   { name: "test:smoke", script: "test:smoke" },
   { name: "test:byok", script: "test:byok" },
@@ -74,6 +78,7 @@ const steps = [
 function skipReason(step) {
   if (profile === 'package' && !step.packageOnly) return 'validating an npm release archive';
   if (profile !== 'package' && step.packageOnly) return 'requires an npm release archive';
+  if (profile === "windows" && !step.windows) return "not part of Windows contract";
   if (profile === "docs" && !step.docs) return "documentation-only change";
   if (profile === "archive" && step.requiresGit)
     return "validating an already exported archive";
 
@@ -44,9 +44,9 @@ test('Windows source preflight requires a local NTFS checkout', () => {
     checkWindowsSourceLocation({ platform: 'win32', cwd: 'C:\\repo', execFile }),
     { ok: true, skipped: false },
   );
-  assert.deepEqual(calls.map(([command, args]) => [command, args[1]]), [
-    ['fsutil', 'drivetype'],
-    ['fsutil', 'volumeinfo'],
+  assert.deepEqual(calls.map(([command, args]) => [command, args[1], args[2]]), [
+    ['fsutil', 'drivetype', 'C:'],
+    ['fsutil', 'volumeinfo', 'C:'],
   ]);
 });
 
@@ -740,15 +740,18 @@ test('CI aggregate rejects failed, cancelled, missing and unexpectedly skipped c
     assert.notEqual(run({ ...full, DOCS_ONLY: scope }), 0);
 });
 
-test('ordinary CI pauses Windows without invoking release-only matrices', () => {
+test('ordinary CI runs a focused Windows contract while compatibility remains macOS/Linux', () => {
   const readWorkflow = name => parseYaml(readFileSync(new URL(`../.github/workflows/${name}.yml`, import.meta.url), 'utf8'));
   const ci = readWorkflow('ci');
   assert.ok(Object.hasOwn(ci.on, 'pull_request'));
   assert.deepEqual(ci.on.push.branches, ['main']);
   assert.deepEqual(Object.keys(ci.jobs).sort(), ['changes', 'docs', 'verification', 'verify']);
-  assert.deepEqual(ci.jobs.verify.strategy.matrix.os, ['ubuntu-latest', 'macos-latest']);
+  assert.deepEqual(ci.jobs.verify.strategy.matrix.os, ['ubuntu-latest', 'macos-latest', 'windows-latest']);
   assert.deepEqual(ci.jobs.verify.strategy.matrix.node, ['24']);
-  assert.deepEqual(ci.jobs.verify.strategy.matrix.include, [{ os: 'ubuntu-latest', node: '24', profile: 'full' }]);
+  assert.deepEqual(ci.jobs.verify.strategy.matrix.include, [
+    { os: 'ubuntu-latest', node: '24', profile: 'full' },
+    { os: 'windows-latest', node: '24', profile: 'windows' },
+  ]);
   assert.equal(ci.jobs.verify.needs, 'changes');
   assert.equal(ci.jobs.verify.if, "needs.changes.outputs.docs_only == 'false'");
   assert.equal(ci.jobs.docs.if, "needs.changes.outputs.docs_only == 'true'");
@@ -758,12 +761,11 @@ test('ordinary CI pauses Windows without invoking release-only matrices', () =>
   const compatibility = readWorkflow('compatibility');
   assert.deepEqual(Object.keys(compatibility.on).sort(), ['schedule', 'workflow_dispatch']);
   assert.deepEqual(compatibility.jobs.compatibility.strategy.matrix.node, ['22.19.0', '24.2.0', '25', '26']);
-  assert.deepEqual(compatibility.jobs.compatibility.strategy.matrix.os, ci.jobs.verify.strategy.matrix.os);
+  assert.deepEqual(compatibility.jobs.compatibility.strategy.matrix.os, ['ubuntu-latest', 'macos-latest']);
   const audit = readWorkflow('security');
   assert.ok(Object.hasOwn(audit.on, 'pull_request'));
   assert.ok(audit.jobs['source-history-artifact'].steps.some(step => step.run?.includes('gitleaks dir dist')));
 });
-
 test('manual source candidates pin every checkout and receipt to the selected revision', () => {
   const workflow = parseYaml(readFileSync(new URL('../.github/workflows/source-candidate.yml', import.meta.url), 'utf8'));
   assert.deepEqual(Object.keys(workflow.on).sort(), ['workflow_call', 'workflow_dispatch']);
@@ -891,6 +893,47 @@ test('candidate rejects mismatched receipts and requires successful same-revisio
 });
 
 
+test('Windows contract profile fails closed off Windows', () => {
+  const result = spawnSync(process.execPath, ['scripts/verify.mjs', '--profile', 'windows', '--list'], {
+    cwd: path.resolve('.'),
+    encoding: 'utf8',
+  });
+  if (process.platform === 'win32') {
+    assert.equal(result.status, 0, result.stderr);
+  } else {
+    assert.notEqual(result.status, 0);
+    assert.match(result.stderr, /requires a Windows host/);
+  }
+});
+
+test('Windows contract profile selects focused gates', () => {
+  const root = mkdtempSync(path.join(tmpdir(), 'windows-profile-'));
+  try {
+    const fixture = path.join(root, 'verify.mjs');
+    copyFileSync(new URL('../scripts/verify.mjs', import.meta.url), fixture);
+    const preload = path.join(root, 'platform.cjs');
+    writeFileSync(preload, "Object.defineProperty(process, 'platform', { value: 'win32' });\n");
+    const result = spawnSync(process.execPath, ['--require', preload, fixture, '--profile', 'windows', '--list'], {
+      cwd: root,
+      encoding: 'utf8',
+      env: { ...process.env },
+    });
+    assert.equal(result.status, 0, result.stderr);
+    assert.deepEqual(result.stdout.trim().split('\n'), [
+      'check:source',
+      'check:tsconfig',
+      'export source preview',
+      'test:release-tools',
+      'build',
+      'check:standalone',
+      'test:artifact',
+      'test:windows',
+    ]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test('source inventory rejects unregistered, missing and duplicate first-party test gates', () => {
   const existing = 'packages/example/src/existing.test.ts';
   const omitted = 'packages/example/test/omitted.spec.tsx';
 
@@ -1,6 +1,9 @@
 {
   "comment": "Vitest suites for the standalone distribution, grouped by the gate that runs them. `vitest.oss.config.mjs` includes every group; `scripts/run-vitest-suite.mjs <group>` runs one. Add a test file here rather than in package.json or the Vitest config.",
   "suites": {
+    "windows": [
+      "test/windows-contract.test.mjs"
+    ],
     "capability": [
       "packages/agent-core/test/unit/bash-subprocess-env.test.ts",
       "packages/agent-modules/permission/test/unit/permission/bash-policy-regressions.test.ts",
 
@@ -0,0 +1,19 @@
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import { checkWindowsSourceLocation } from "../scripts/check-windows-source-location.mjs";
+import { resolveWslPath } from "../packages/tui/src/host/wsl-path.js";
+
+const windowsPath = String.raw`D:\Users\demo\Documents\Screen shots\截图.png`;
+
+describe.skipIf(process.platform !== "win32")("Windows source contract", () => {
+  it("accepts the Windows checkout on a local NTFS volume", () => {
+    assert.deepEqual(checkWindowsSourceLocation(), {
+      ok: true,
+      skipped: false,
+    });
+  });
+
+  it("preserves Windows path syntax on the native host", async () => {
+    assert.equal(await resolveWslPath(windowsPath), windowsPath);
+  });
+});