suite_tcl90: tclvfs -> forTcl9 branch (1.5.0); version-derived vfs names; familyrev default 2

User direction: the BAWT-shipped tclvfs 1.5.0 comes from the forTcl9
branch of the same core.tcl-lang.org/tclvfs repo our trunk ref trailed
at 1.4.2 - tcl9 suites move to it (a future suite_tcl86 keeps trunk;
recorded in sources.config). Both flows updated: sources.config ref +
build.zig.zon per-checkin tarball pin (75a2672991).

build_tclvfs_shared.zig gets the G-107 derivation treatment: every
version-derived name (package dir, dlls, rc fields, configured
vfs.tcl/pkgIndex.tcl) now follows the checkout's AC_INIT via
versionInfo() - the hardcoded 1.4.2 was the same stamped-mismatch class
as the thread 3.0.1 case. build905 consumers use the derived info
(szip staging, family staging, family_check args, artifact metadata).

forTcl9 build glue: export guard is now lowercase BUILD_vfs;
HAVE_SYS_STAT_H defined; and an include-order shim TU works around
zig's mingw headers defining __stat64 as a MACRO for _stat64 - tcl.h's
'typedef struct __stat64 Tcl_StatBuf' parsed before <sys/stat.h> binds
a forever-incomplete tag and forTcl9's direct Tcl_StatBuf field access
fails (MSVC has a real tag; upstream never sees this; -include trips
zig cc CacheCheckFailed, hence the generated-TU overlay).

Verification: all three family members PASS self-containment with vfs
1.5.0 incl the functional zip-mount round-trip; tclvfs test gate PASS
51/42/9/0 twice-deterministic - the branch CLEARED the whole 1.4.2-era
baseline (glob-nomatch drift entries now pass, network vfsFtp/vfsUrl
now skip) - baseline re-established empty. familyrev default bumped to
2 (r1 published+immutable; r2 emitted locally + staged to the runtime
store; r2 publication is a user decision). Wrapped kits confirm the
resolution skew the user found is gone: punk9bi_beta script-mode
'package require vfs' now 1.5.0 (boot loads the runtime's copy - both
tiers now agree).

Assisted-by: harness=claude; primary-model=claude-fable-5; api-location=anthropic.com

src/buildsuites/suite_tcl90/build.zig.zon

@@ -33,10 +33,10 @@
             .hash = "N-V-__8AALOqFAA-WUgJ777DabyIuinMYLe_jXido0KjnJbT",
             .lazy = true,
         },
-        //tclvfs trunk checkout f082c47f9b 2023-09-05 (1.4.2 era)
+        //tclvfs forTcl9 branch checkout 75a2672991 (1.5.0 - the branch BAWT builds ship; tcl9 suites only, user 2026-07-22)
         .tclvfs = .{
-            .url = "https://core.tcl-lang.org/tclvfs/tarball/f082c47f9b2e04566e8ae70d56c6a02980d43674/tclvfs.tar.gz",
-            .hash = "N-V-__8AAK_2DQDNpjv04LswPFyezzY97rkc5cuwcaqO-Nyq",
+            .url = "https://core.tcl-lang.org/tclvfs/tarball/75a26729914e2fbc68bf955315d34dc0302e3dbd7e239109785f9f5e30bd5fdd/tclvfs.tar.gz",
+            .hash = "N-V-__8AAHINEQBULsYz_YEtRrrYaPFYdWmEQqvpXW_6Rcl7",
             .lazy = true,
         },
         //tk core-9-0-branch checkout effef6c657 2025-04-07 (9.0.2)

src/buildsuites/suite_tcl90/build905.zig

@@ -2040,7 +2040,8 @@ pub fn build(b: *std.Build) !void {
     //_ = try tclvfs_static.vfsadd_tclvfs_files(tcl_source_folder, "../tclvfs", b, make_vfs_root);
     _ = try tclvfs_shared.vfsadd_tclvfs_files(tcl_source_folder, "../tclvfs", b, make_vfs_root);
     //hack
-    _ = make_vfs_root.addCopyFile(tclvfs_compile.getEmittedBin(), "base/lib/vfs1.4.2/tcl9vfs142.dll");
+    const tclvfs_info = tclvfs_shared.versionInfo(b, "../tclvfs");
+    _ = make_vfs_root.addCopyFile(tclvfs_compile.getEmittedBin(), b.fmt("base/lib/vfs{s}/{s}", .{ tclvfs_info.dotversion, tclvfs_info.dll_file }));
     // *****************************
 
     //vqtcl/vlerq zip payload removed with the rest of the vqtcl wiring (user 2026-07-20;
@@ -2383,7 +2384,7 @@ pub fn build(b: *std.Build) !void {
                 //package-search hook for the lib/ tree
                 _ = famwf.add("base/lib/pkgIndex.tcl", family_libext_pkgindex);
                 //batteries (installed shape)
-                try tclvfs_shared.familyadd_tclvfs_package("../tclvfs", b, famwf, "base/lib/vfs" ++ tclvfs_shared.dotversion, tclvfs_compile);
+                try tclvfs_shared.familyadd_tclvfs_package("../tclvfs", b, famwf, b.fmt("base/lib/vfs{s}", .{tclvfs_info.dotversion}), tclvfs_compile);
                 _ = famwf.addCopyFile(thread_build.pkgidx, b.fmt("base/lib/thread{s}/pkgIndex.tcl", .{thread_build.version}));
                 _ = famwf.addCopyFile(thread_build.lib.getEmittedBin(), b.fmt("base/bin/{s}", .{thread_build.dll_file}));
                 _ = famwf.addCopyDirectory(tcllib_out, b.fmt("base/lib/tcllib{s}", .{tcllib_ver}), .{});
@@ -2436,7 +2437,7 @@ pub fn build(b: *std.Build) !void {
                 check.has_side_effects = true;
                 check.addFileArg(b.path("tools/family_check.tcl"));
                 check.addArgs(&.{ "-exe", installed_path, "-variant", fk.variant, "-expectpatch", tcl_h_patchlevel });
-                check.addArgs(&.{ "-thread", thread_build.version, "-vfs", tclvfs_shared.dotversion, "-tcllib", tcllib_ver });
+                check.addArgs(&.{ "-thread", thread_build.version, "-vfs", tclvfs_info.dotversion, "-tcllib", tcllib_ver });
                 if (std.mem.eql(u8, fk.variant, "punk-bi")) {
                     check.addArgs(&.{ "-tk", tkb.patchlevel, "-tklib", tklib_ver });
                 }
@@ -2451,7 +2452,11 @@ pub fn build(b: *std.Build) !void {
             //family runtime executes real tooling from its attached batteries.
             //Depends on the checks: only verified kits get artifact records.
             //Publication to the real punkbin repo stays a deliberate user step.
-            const familyrev = b.option(u32, "familyrev", "assembly revision N for the -r<N> family artifact names (kit-family-artifacts; default 1)") orelse 1;
+            //default 2: r1 of every (9.0.5, variant) pair was PUBLISHED to punkbin
+            //2026-07-22 and is immutable - subsequent assemblies (first content
+            //change: tclvfs forTcl9/1.5.0) emit as r2 until r2 is itself published
+            //and superseded. Bump this default whenever the current rev publishes.
+            const familyrev = b.option(u32, "familyrev", "assembly revision N for the -r<N> family artifact names (kit-family-artifacts; default 2 - r1 published 2026-07-22)") orelse 2;
             const family_artifacts_step = b.step("kit-family-artifacts", "emit punkbin-layout artifact copies (-r<N>) + toml metadata + sha1sums for the verified family kits -> <prefix>/family/punkbin/<target>");
             const artifacts_outdir = common.replaceAll(b, b.pathJoin(&.{ b.install_path, "family", "punkbin", "win32-x86_64" }), "\\", "/");
             const uuid_tcl = common.manifestUuid(b, tcl_source_folder);
@@ -2466,7 +2471,7 @@ pub fn build(b: *std.Build) !void {
             emit.addFileArg(b.path("tools/family_artifacts.tcl"));
             emit.addArgs(&.{ "-outdir", artifacts_outdir, "-rev", b.fmt("{d}", .{familyrev}), "-target", "win32-x86_64" });
             emit.addArgs(&.{ "-suite", "suite_tcl90", "-tclpatch", tcl_h_patchlevel, "-zig", builtin.zig_version_string, "-optimize", @tagName(optimize) });
-            emit.addArgs(&.{ "-components", b.fmt("Thread {s} vfs {s} tcllib {s} tcllibc {s}", .{ thread_build.version, tclvfs_shared.dotversion, tcllib_ver, tcllib_ver }) });
+            emit.addArgs(&.{ "-components", b.fmt("Thread {s} vfs {s} tcllib {s} tcllibc {s}", .{ thread_build.version, tclvfs_info.dotversion, tcllib_ver, tcllib_ver }) });
             emit.addArgs(&.{ "-bicomponents", b.fmt("Tk {s} tklib {s}", .{ tkb.patchlevel, tklib_ver }) });
             emit.addArgs(&.{ "-provenance", b.fmt("tcl {s} thread {s} tclvfs {s} tk {s} tcllib {s} tklib {s}", .{ uuid_tcl, uuid_thread, uuid_tclvfs, uuid_tk, uuid_tcllib, uuid_tklib }) });
             emit.addArgs(&.{ "-testreports", testreports_dir });

src/buildsuites/suite_tcl90/build_tclvfs/build_tclvfs_shared.zig

@@ -2,19 +2,44 @@ const std = @import("std");
 const fs = std.fs;
 const common = @import("../build_common.zig");
 
-const tclvfs_dotversion = "1.4.2";
-const tclvfs_nodotversion = "142";
-pub const dotversion = tclvfs_dotversion;
-pub const dll_file = "tcl9vfs" ++ tclvfs_nodotversion ++ ".dll";
+//G-107-style version derivation (2026-07-22): all version-derived tclvfs names
+//(package dir, dll names, rc fields, configured vfs.tcl/pkgIndex.tcl contents)
+//follow the CHECKOUT's AC_INIT - the previously hardcoded 1.4.2 stamped
+//mismatched sources once the tclvfs ref moved to the forTcl9 branch (1.5.0),
+//the same failure class as the thread 3.0.1/3.0.7 case G-107 fixed.
+pub const TclvfsInfo = struct {
+    dotversion: []const u8, //e.g "1.5.0"
+    nodots: []const u8, //e.g "150"
+    dll_file: []const u8, //e.g "tcl9vfs150.dll"
+    dll8_file: []const u8, //e.g "tclvfs150.dll"
+    major: []const u8,
+    minor: []const u8,
+};
+
+pub fn versionInfo(b: *std.Build, comptime tree_from_root: []const u8) TclvfsInfo {
+    const dotversion = common.acInitVersion(b, tree_from_root);
+    const nodots = common.stripChars(b, dotversion, ".");
+    var parts = std.mem.splitScalar(u8, dotversion, '.');
+    const major = parts.next() orelse "0";
+    const minor = parts.next() orelse "0";
+    return .{
+        .dotversion = dotversion,
+        .nodots = nodots,
+        .dll_file = b.fmt("tcl9vfs{s}.dll", .{nodots}),
+        .dll8_file = b.fmt("tclvfs{s}.dll", .{nodots}),
+        .major = b.dupe(major),
+        .minor = b.dupe(minor),
+    };
+}
 
 //configure-products (vfs.tcl, pkgIndex.tcl) generated from their .in templates at
 //configure time. Shared by the prefix install and the G-103 family staging so the
 //package is generated from one derivation.
-fn configuredContent(b: *std.Build, comptime subdir: []const u8, comptime template: []const u8) []const u8 {
+fn configuredContent(b: *std.Build, comptime subdir: []const u8, comptime template: []const u8, info: TclvfsInfo) []const u8 {
     var t: []const u8 = common.readSourceFile(b, subdir ++ "/" ++ template);
-    t = common.replaceAll(b, t, "@PACKAGE_VERSION@", tclvfs_dotversion);
-    t = common.replaceAll(b, t, "@PKG_LIB_FILE9@", dll_file);
-    t = common.replaceAll(b, t, "@PKG_LIB_FILE8@", "tclvfs" ++ tclvfs_nodotversion ++ ".dll");
+    t = common.replaceAll(b, t, "@PACKAGE_VERSION@", info.dotversion);
+    t = common.replaceAll(b, t, "@PKG_LIB_FILE9@", info.dll_file);
+    t = common.replaceAll(b, t, "@PKG_LIB_FILE8@", info.dll8_file);
     return t;
 }
 
@@ -23,7 +48,8 @@ fn configuredContent(b: *std.Build, comptime subdir: []const u8, comptime templa
 //dll alongside (vfs.tcl loads it from its own dir via ::vfs::self). Formerly a
 //suite.tcl post-build block. Windows dll naming - the cross-target story is G-105's.
 pub fn install_tclvfs_package(comptime subdir: []const u8, b: *std.Build, tclvfs_compile: *std.Build.Step.Compile) !void {
-    const pkgsub = "lib/vfs" ++ tclvfs_dotversion;
+    const info = versionInfo(b, subdir);
+    const pkgsub = b.fmt("lib/vfs{s}", .{info.dotversion});
     const install_scripts = b.addInstallDirectory(.{
         .source_dir = b.path(subdir ++ "/library"),
         .install_dir = .prefix,
@@ -35,7 +61,7 @@ pub fn install_tclvfs_package(comptime subdir: []const u8, b: *std.Build, tclvfs
     const install_template = b.addInstallDirectory(.{
         .source_dir = b.path(subdir ++ "/library/template"),
         .install_dir = .prefix,
-        .install_subdir = pkgsub ++ "/template",
+        .install_subdir = b.fmt("{s}/template", .{pkgsub}),
     });
     b.getInstallStep().dependOn(&install_template.step);
     const wf = b.addWriteFiles();
@@ -43,57 +69,57 @@ pub fn install_tclvfs_package(comptime subdir: []const u8, b: *std.Build, tclvfs
         .{ "library/vfs.tcl.in", "vfs.tcl" },
         .{ "pkgIndex.tcl.in", "pkgIndex.tcl" },
     }) |pair| {
-        const gen = wf.add(pair[1], configuredContent(b, subdir, pair[0]));
-        const inst = b.addInstallFileWithDir(gen, .prefix, pkgsub ++ "/" ++ pair[1]);
+        const gen = wf.add(pair[1], configuredContent(b, subdir, pair[0], info));
+        const inst = b.addInstallFileWithDir(gen, .prefix, b.fmt("{s}/{s}", .{ pkgsub, pair[1] }));
         b.getInstallStep().dependOn(&inst.step);
     }
-    const dll_inst = b.addInstallFileWithDir(tclvfs_compile.getEmittedBin(), .prefix, pkgsub ++ "/" ++ dll_file);
+    const dll_inst = b.addInstallFileWithDir(tclvfs_compile.getEmittedBin(), .prefix, b.fmt("{s}/{s}", .{ pkgsub, info.dll_file }));
     b.getInstallStep().dependOn(&dll_inst.step);
 }
 
 //G-103: write the SAME installed-shape vfs package into a family staging tree
-//(WriteFiles) at destsub (e.g "base/lib/vfs1.4.2") - scripts, template dir,
+//(WriteFiles) at destsub (e.g "base/lib/vfs1.5.0") - scripts, template dir,
 //generated vfs.tcl/pkgIndex.tcl, dll inside the package dir.
-pub fn familyadd_tclvfs_package(comptime subdir: []const u8, b: *std.Build, wf: *std.Build.Step.WriteFile, comptime destsub: []const u8, tclvfs_compile: *std.Build.Step.Compile) !void {
+pub fn familyadd_tclvfs_package(comptime subdir: []const u8, b: *std.Build, wf: *std.Build.Step.WriteFile, destsub: []const u8, tclvfs_compile: *std.Build.Step.Compile) !void {
+    const info = versionInfo(b, subdir);
     _ = wf.addCopyDirectory(b.path(subdir ++ "/library"), destsub, .{ .include_extensions = &.{".tcl"} });
-    _ = wf.addCopyDirectory(b.path(subdir ++ "/library/template"), destsub ++ "/template", .{});
-    _ = wf.add(destsub ++ "/vfs.tcl", configuredContent(b, subdir, "library/vfs.tcl.in"));
-    _ = wf.add(destsub ++ "/pkgIndex.tcl", configuredContent(b, subdir, "pkgIndex.tcl.in"));
-    _ = wf.addCopyFile(tclvfs_compile.getEmittedBin(), destsub ++ "/" ++ dll_file);
+    _ = wf.addCopyDirectory(b.path(subdir ++ "/library/template"), b.fmt("{s}/template", .{destsub}), .{});
+    _ = wf.add(b.fmt("{s}/vfs.tcl", .{destsub}), configuredContent(b, subdir, "library/vfs.tcl.in", info));
+    _ = wf.add(b.fmt("{s}/pkgIndex.tcl", .{destsub}), configuredContent(b, subdir, "pkgIndex.tcl.in", info));
+    _ = wf.addCopyFile(tclvfs_compile.getEmittedBin(), b.fmt("{s}/{s}", .{ destsub, info.dll_file }));
 }
 
 pub fn vfsadd_tclvfs_files(comptime tcldir: []const u8, comptime subdir: []const u8, b: *std.Build, vfswrite: *std.Build.Step.WriteFile) !*std.Build.Step.WriteFile {
-    //_ = tcldir;
-    //const version = "1.4.2";
-    //recursive copy
-    //_ = make_vfs_root.addCopyDirectory(b.path(tcl_source_folder ++ "/../tclvfs/library"), "base/lib/vfs1.4.2", .{});
-    _ = vfswrite.addCopyDirectory(b.path(tcldir ++ "/" ++ subdir ++ "/library"), b.pathJoin(&.{ "base", "lib", "vfs" ++ tclvfs_dotversion }), .{});
-
+    //recursive copy of the script library into the szip staging tree (the
+    //generated configure-products + dll are added by the caller/familyadd paths)
+    const info = versionInfo(b, tcldir ++ "/" ++ subdir);
+    _ = vfswrite.addCopyDirectory(b.path(tcldir ++ "/" ++ subdir ++ "/library"), b.fmt("base/lib/vfs{s}", .{info.dotversion}), .{});
     return vfswrite;
 }
+
 pub fn build_tclvfs(comptime tcldir: []const u8, comptime subdir: []const u8, b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode, stublib: *std.Build.Step.Compile) !*std.Build.Step.Compile {
-    //review - libname Vfs vs vfs???
+    const info = versionInfo(b, subdir);
     const lib = b.addLibrary(.{
         .linkage = .dynamic,
-        .name = "tcl9vfs142",
+        .name = b.fmt("tcl9vfs{s}", .{info.nodots}),
         .root_module = b.createModule(.{
             .target = target,
             .optimize = optimize,
         }),
     });
-    //_ = stublib;
     var flags = std.array_list.Managed([]const u8).init(b.allocator);
     defer flags.deinit();
-    //try flags.appendSlice(&.{ "-Wall", "-O3" });
     try flags.appendSlice(&.{ "-Wall", "-O3", "-fomit-frame-pointer" });
     try flags.appendSlice(&.{
         "-DPACKAGE_NAME=\"vfs\"",
         "-DPACKAGE_TARNAME=\"vfs\"",
-        "-DPACKAGE_VERSION=\"" ++ tclvfs_dotversion ++ "\"",
-        "-DPACKAGE_STRING=\"vfs " ++ tclvfs_dotversion ++ "\"",
+        b.fmt("-DPACKAGE_VERSION=\"{s}\"", .{info.dotversion}),
+        b.fmt("-DPACKAGE_STRING=\"vfs {s}\"", .{info.dotversion}),
         "-DPACKAGE_BUGREPORT=\"\"",
         "-DPACKAGE_URL=\"\"",
-        "-DBUILD_VFS=1",
+        //forTcl9 vfs.c guards <sys/stat.h> behind HAVE_SYS_STAT_H and needs the
+        //COMPLETE Tcl_StatBuf - see the include-order shim below.
+        "-DHAVE_SYS_STAT_H=1",
         "-DTCL_CFG_OPTIMIZED=1",
         "-DUSE_TCL_STUBS=1",
         "-DZIPFS_BUILD=1",
@@ -101,24 +127,39 @@ pub fn build_tclvfs(comptime tcldir: []const u8, comptime subdir: []const u8, b:
     });
     if (target.result.os.tag == .windows) {
         try flags.appendSlice(&.{
-            "-static-libgcc",
+            //forTcl9 export guard is lowercase BUILD_vfs ("should be undefined for
+            //Unix" per vfs.c) - the trunk-era BUILD_VFS spelling no longer matches.
+            //(-static-libgcc dropped from the cflags: a link-stage arg clang
+            //reports unused at compile - zig manages runtime-lib linkage anyway.)
+            "-DBUILD_vfs=/**/",
         });
     }
-    //-DBUILD_VFS only on windows? value?
 
-    var sources = std.array_list.Managed([]const u8).init(b.allocator);
-    try sources.append(subdir ++ "/generic/vfs.c");
     lib.root_module.addIncludePath(b.path(subdir));
     lib.root_module.addIncludePath(b.path(subdir ++ "/generic"));
     lib.root_module.addIncludePath(b.path(tcldir ++ "/generic"));
-    lib.root_module.addIncludePath(b.path(tcldir ++ "/generic"));
     if (target.result.os.tag == .windows) {
         lib.root_module.addIncludePath(b.path(tcldir ++ "/win"));
     } else {
         lib.root_module.addIncludePath(b.path(tcldir ++ "/unix"));
     }
-    lib.root_module.addCSourceFiles(.{
-        .files = sources.items,
+    //Include-order shim (overlay TU - source trees never written): under zig's
+    //mingw headers '__stat64' is a MACRO for _stat64 (_mingw_stat64.h, pulled in
+    //by <sys/stat.h>); tcl.h's 'typedef struct __stat64 Tcl_StatBuf' parsed
+    //BEFORE that include binds a raw forever-incomplete __stat64 tag and the
+    //forTcl9 vfs.c's direct Tcl_StatBuf field accesses then fail. Compiling a
+    //generated TU that includes <sys/stat.h> first makes the macro visible when
+    //tcl.h parses. (MSVC has a real struct __stat64 tag - upstream never sees
+    //this. A -include flag would be simpler but trips zig cc's CacheCheckFailed.)
+    const wf_shim = b.addWriteFiles();
+    const vfs_shim = wf_shim.add("vfs_statorder_shim.c",
+        \\/* generated include-order shim - see build_tclvfs_shared.zig */
+        \\#include <sys/stat.h>
+        \\#include "vfs.c"
+        \\
+    );
+    lib.root_module.addCSourceFile(.{
+        .file = vfs_shim,
         .flags = flags.items,
     });
 
@@ -127,16 +168,15 @@ pub fn build_tclvfs(comptime tcldir: []const u8, comptime subdir: []const u8, b:
     lib.root_module.addWin32ResourceFile(.{
         .file = b.path(subdir ++ "/win/tclvfs.rc"),
         .flags = &.{
-            "-DPACKAGE_MAJOR=1",
-            "-DPACKAGE_MINOR=4",
-            "-DPACKAGE_VERSION=" ++ tclvfs_dotversion,
-            "-DDOTVERSION=" ++ tclvfs_dotversion,
-            "-DCOMMAVERSION=" ++ tclvfs_dotversion,
-            "-DVERSION=" ++ tclvfs_nodotversion,
+            b.fmt("-DPACKAGE_MAJOR={s}", .{info.major}),
+            b.fmt("-DPACKAGE_MINOR={s}", .{info.minor}),
+            b.fmt("-DPACKAGE_VERSION={s}", .{info.dotversion}),
+            b.fmt("-DDOTVERSION={s}", .{info.dotversion}),
+            b.fmt("-DCOMMAVERSION={s}", .{info.dotversion}),
+            b.fmt("-DVERSION={s}", .{info.nodots}),
         },
     }); //ignored for non-windows targets
-    // COMMAVERSION??? VERSION???
 
     b.installArtifact(lib);
-    return lib; //static library
+    return lib;
 }

src/buildsuites/suite_tcl90/expected_test_failures_tclvfs.txt

@@ -3,23 +3,14 @@
 # step (policy gate) fails on any failed test NOT listed here, and notes listed
 # tests that no longer fail (candidates for removal).
 #
-# Baseline established 2026-07-21 against tclvfs trunk (vfs 1.4.2), suite-built
-# tclsh90s.exe 9.0.5, machine superbee (windows 11). Census totals at capture:
-# 51 run / 39 passed / 5 skipped / 7 failed, all dispositioned below.
-
-# -- tcl9 glob-nomatch semantics through vfs handlers: glob on a non-matching
-# pattern / non-present directory inside a mounted vfs returns an empty result
-# where the tests (written for tcl8-era vfs) expect the "no files matched"
-# error. Consistent behaviour drift, not a build defect; candidate upstream
-# test/behaviour reconciliation.
-vfs-4.2
-vfsZip-1.6
-vfsZip-1.7
-
-# -- network-reaching tests (the suite census runs offline-tolerant): remote
-# FTP hosts (ftp.ucsd.edu, ftp.tcl.tk) unreachable/retired. The goal survey
-# (G-107) anticipated skipping/dispositioning vfsFtp/vfsUrl.
-vfsFtp-1.1
-vfsFtp-1.2
-vfsFtp-1.3
-vfsUrl-2.1
+# Baseline re-established 2026-07-22 against the tclvfs forTcl9 branch
+# (vfs 1.5.0, checkout 75a2672991), suite-built tclsh90s.exe 9.0.5, machine
+# superbee (windows 11). Census totals at capture: 51 run / 42 passed /
+# 9 skipped / 0 failed - the branch move CLEARED the whole 1.4.2-era baseline:
+# the tcl9 glob-nomatch drift entries (vfs-4.2, vfsZip-1.6/1.7) now pass (the
+# forTcl9 branch reconciles tcl9 vfs-handler glob semantics), and the
+# network-reaching vfsFtp-1.1/1.2/1.3 + vfsUrl-2.1 entries now SKIP rather
+# than fail under this branch's suite. Prior 1.4.2-era baseline + dispositions:
+# git history of this file (2026-07-21 capture).
+#
+# (no expected failures)

src/buildsuites/suite_tcl90/sources.config

@@ -43,7 +43,11 @@
 
 source tcl       fossil https://core.tcl-lang.org/tcl    core-9-0-branch tcl905
 source tclthread fossil https://core.tcl-lang.org/thread trunk           tclthread
-source tclvfs    fossil https://core.tcl-lang.org/tclvfs trunk           tclvfs
+# tclvfs forTcl9 branch (user 2026-07-22): trunk is the 1.4.2 era; forTcl9 carries
+# 1.5.0 (the branch BAWT builds ship). TCL 9 SUITES ONLY - a future suite_tcl86
+# (G-099) keeps trunk. Version-derived names follow the checkout's AC_INIT
+# (build_tclvfs_shared.zig versionInfo - the G-107 derivation pattern).
+source tclvfs    fossil https://core.tcl-lang.org/tclvfs forTcl9         tclvfs
 
 # G-098: Tk + companion script libraries. tklib is pure-tcl (installed by its own
 # installer where that matters); tcllib's accelerators (tcllibc) are built via critcl.