@@ -185,8 +185,9 @@ pub fn buildEnvelope(
     return serialize.serializeEnvelope(allocator, all.items, null, components.items, &pb, true);
 }
 
-/// AOT-compile the WHOLE eager bootstrap (`bootstrap.FILES` — clojure.core +
-/// the 23 non-core bundled `.clj` libs) to one bytecode envelope, mirroring
+/// AOT-compile the WHOLE eager bootstrap (`bootstrap.ACTIVE_FILES` — clojure.core
+/// + the non-core bundled `.clj` libs this build carries) to one bytecode
+/// envelope, mirroring
 /// `bootstrap.loadCoreFiles`'s per-file read→analyze→compile→eval loop but
 /// CAPTURING each form's compiled chunk (D-452 Part B / ADR-0056 Cycle 3). The
 /// load path (`bootstrap.loadCoreAot`) runs this via `driver.runEnvelope`
@@ -361,9 +362,17 @@ const BuildSpec = union(enum) {
 /// per `spec`, and append it to a copy of the running cljw binary as a
 /// self-contained `"CLJC"`-trailered executable. `buildFile` / `buildMainFile`
 /// are the two thin entry points (F-009/F-011 — one setup, one write tail).
-fn buildArtifact(io: std.Io, gpa: std.mem.Allocator, arena: std.mem.Allocator, out_path: []const u8, load_paths: []const []const u8, spec: BuildSpec) !void {
+///
+/// `stdout` is the CLI's one process-shared writer, threaded in for the same
+/// reason `tryRunEmbedded` takes it (D-096): build-time eval runs the entry's
+/// top-level forms, and their `println` must land on that single offset-tracking
+/// writer. A fresh per-call writer restarts at file offset 0, so on a seekable
+/// stdout (`cljw build app.clj > build.log`) every form overwrote the previous
+/// one and only the last survived.
+fn buildArtifact(io: std.Io, gpa: std.mem.Allocator, arena: std.mem.Allocator, stdout: *std.Io.Writer, out_path: []const u8, load_paths: []const []const u8, spec: BuildSpec) !void {
     var rt = Runtime.init(io, gpa);
     defer rt.deinit();
+    rt.stdout = stdout;
     var env = try Env.init(&rt);
     defer env.deinit();
     driver.installVTable(&rt);
@@ -395,6 +404,9 @@ fn buildArtifact(io: std.Io, gpa: std.mem.Allocator, arena: std.mem.Allocator, o
     var ow = out.writer(io, &wbuf);
     try ow.interface.writeAll(artifact);
     try ow.interface.flush();
+    // Build-time eval's own output, flushed BEFORE the exit barrier below —
+    // that barrier may hard-exit, which would drop a buffered tail.
+    try stdout.flush();
     // Exit barrier (ADR-0176): build-time eval may have spawned workers;
     // hard-exit if any is live rather than tear down under it (D-548(a)).
     @import("../runtime/thread.zig").exitBarrier(&rt);
@@ -404,18 +416,18 @@ fn buildArtifact(io: std.Io, gpa: std.mem.Allocator, arena: std.mem.Allocator, o
 /// payload envelope and append it to a copy of the running cljw binary as a
 /// self-contained artifact with a `"CLJC"` trailer (ADR-0034 amendment 1/2).
 /// Build-time eval runs top-level side effects (A1-D2). The output is executable.
-pub fn buildFile(io: std.Io, gpa: std.mem.Allocator, arena: std.mem.Allocator, in_path: []const u8, out_path: []const u8, load_paths: []const []const u8) !void {
+pub fn buildFile(io: std.Io, gpa: std.mem.Allocator, arena: std.mem.Allocator, stdout: *std.Io.Writer, in_path: []const u8, out_path: []const u8, load_paths: []const []const u8) !void {
     const source = try readFileAll(io, gpa, in_path);
     defer gpa.free(source);
-    return buildArtifact(io, gpa, arena, out_path, load_paths, .{ .script = .{ .src = source, .label = in_path } });
+    return buildArtifact(io, gpa, arena, stdout, out_path, load_paths, .{ .script = .{ .src = source, .label = in_path } });
 }
 
 /// `cljw build -m <ns> [args…] -o <out>` (main mode, ADR-0034 am4): embed the
 /// require closure for `<ns>` + an entry manifest; the produced binary invokes
 /// `(<ns>/-main args)` at run, NOT at build (so a server `-main` does not hang
 /// the build).
-pub fn buildMainFile(io: std.Io, gpa: std.mem.Allocator, arena: std.mem.Allocator, ns: []const u8, args: []const []const u8, out_path: []const u8, load_paths: []const []const u8) !void {
-    return buildArtifact(io, gpa, arena, out_path, load_paths, .{ .main = .{ .ns = ns, .args = args } });
+pub fn buildMainFile(io: std.Io, gpa: std.mem.Allocator, arena: std.mem.Allocator, stdout: *std.Io.Writer, ns: []const u8, args: []const []const u8, out_path: []const u8, load_paths: []const []const u8) !void {
+    return buildArtifact(io, gpa, arena, stdout, out_path, load_paths, .{ .main = .{ .ns = ns, .args = args } });
 }
 
 /// Startup hook: if the running binary carries an embedded payload trailer,
@@ -657,7 +669,7 @@ test "aot: full bootstrap round-trips — a NON-core lib restores from bytecode
         var table = macro_dispatch.Table.init(A);
         defer table.deinit();
         try bootstrap.setupCorePrefix(&rt, &env, &table);
-        blob = try buildBootstrapEnvelope(A, &rt, &env, &table, arena, bootstrap.FILES);
+        blob = try buildBootstrapEnvelope(A, &rt, &env, &table, arena, bootstrap.ACTIVE_FILES);
     }
     defer A.free(blob);
 
@@ -676,8 +688,8 @@ test "aot: full bootstrap round-trips — a NON-core lib restores from bytecode
     try bootstrap.setupCorePrefix(&rt, &env, &table);
     // The whole eager bootstrap from the region blob (no .clj re-parse) — mirrors
     // the loadCoreAot path: pre-register loaded_libs, then run every region in order.
-    try bootstrap.markFilesLoaded(&rt, bootstrap.FILES);
-    try bootstrap.runEagerRegions(&rt, &env, arena, blob, bootstrap.FILES);
+    try bootstrap.markFilesLoaded(&rt, bootstrap.ACTIVE_FILES);
+    try bootstrap.runEagerRegions(&rt, &env, arena, blob, bootstrap.ACTIVE_FILES);
 
     // clojure.string/upper-case is a non-core lib var: present ONLY if the
     // non-core AOT chunks ran. Call it to prove the restored fn dispatches.
 
@@ -241,13 +241,13 @@ pub fn dispatch(init: std.process.Init) !void {
                 std.process.exit(1);
             }
             if (main_ns) |mns| {
-                builder.buildMainFile(io, gpa, arena, mns, main_args.items, out, deps.load_paths) catch |err| {
+                builder.buildMainFile(io, gpa, arena, stdout, mns, main_args.items, out, deps.load_paths) catch |err| {
                     try stderr.print("build failed: {s}\n", .{@errorName(err)});
                     try stderr.flush();
                     std.process.exit(1);
                 };
             } else {
-                builder.buildFile(io, gpa, arena, in_path.?, out, deps.load_paths) catch |err| {
+                builder.buildFile(io, gpa, arena, stdout, in_path.?, out, deps.load_paths) catch |err| {
                     try stderr.print("build failed: {s}\n", .{@errorName(err)});
                     try stderr.flush();
                     std.process.exit(1);
 
@@ -46,7 +46,7 @@ pub fn main(init: std.process.Init) !void {
     // Part B — the non-core libs no longer re-parse from source every startup).
     try bootstrap.setupCorePrefix(&rt, &env, &macro_table);
 
-    const payload = try builder.buildBootstrapEnvelope(gpa, &rt, &env, &macro_table, arena, bootstrap.FILES);
+    const payload = try builder.buildBootstrapEnvelope(gpa, &rt, &env, &macro_table, arena, bootstrap.ACTIVE_FILES);
     defer gpa.free(payload);
 
     const out = try std.Io.Dir.cwd().createFile(io, out_path, .{ .truncate = true });
@@ -64,8 +64,8 @@ pub fn main(init: std.process.Init) !void {
         var aw: std.Io.Writer.Allocating = .init(gpa);
         errdefer aw.deinit();
         const w = &aw.writer;
-        try w.writeInt(u32, @intCast(bootstrap.FILES.len), .little);
-        for (bootstrap.FILES) |file| {
+        try w.writeInt(u32, @intCast(bootstrap.ACTIVE_FILES.len), .little);
+        for (bootstrap.ACTIVE_FILES) |file| {
             const src = file.source.?;
             const packed_bytes = try serialize.flateCompress(gpa, src);
             defer gpa.free(packed_bytes);
 
@@ -6,8 +6,9 @@
 //!
 //! ### Multi-file loader (ADR-0032)
 //!
-//! `loadCore` iterates `FILES`, a flat table of `{label, source}`
-//! pairs. The loader carries **no** namespace knowledge — each `.clj`
+//! `loadCore` iterates `ACTIVE_FILES` — `FILES` (a flat table of
+//! `{label, source, wasm_only}`) minus the entries this build's options
+//! gate out. The loader carries **no** namespace knowledge — each `.clj`
 //! file declares its own namespace via a leading `(in-ns 'foo.bar)`
 //! form (analyzer special form per ADR-0032). After the last file,
 //! `current_ns` resets to `user/` so the REPL prompt lands there.
@@ -57,8 +58,19 @@ pub const FileEntry = struct {
     /// flate-compressed in the `bootstrap_sources` blob; read via
     /// `sourceText` (C5'-b, ADR-0173).
     source: ?[]const u8,
+    /// The file rides the `wasm/` primitive namespace, which is registered
+    /// only under `-Dwasm`. Its `wasm/…` call sites resolve at ANALYZE time,
+    /// so a build without the flag cannot compile it at all.
+    wasm_only: bool = false,
 };
 
+/// Is `entry` part of THIS build's bundled set? The ONE predicate behind both
+/// the walks (`ACTIVE_FILES`) and the resolver (`lookupEmbeddedFile`), so a
+/// gated file can never be active in one and inactive in the other.
+pub fn isActiveFile(entry: FileEntry) bool {
+    return build_options.wasm or !entry.wasm_only;
+}
+
 /// Bootstrap source table — load order matters. `core.clj` must be
 /// first because it lands `(def not ...)` and the future
 /// `clojure.core` companions that subsequent files may reference.
@@ -79,8 +91,10 @@ pub const EAGER_NS = std.StaticStringMap(void).initComptime(.{
     // cljw-SPECIFIC (not in clj's auto-set): the Wasm-component `:require` desugar
     // (ADR-0135 am1) emits `(cljw.wasm/require-component-libspec …)` which is resolved
     // at ANALYZE time — before its own `(require 'cljw.wasm)` prelude EVALs — so the
-    // ns must already be loaded. Eager (91 lines, def-only top level — its `wasm/`
-    // primitive refs are resolved at call time, so loading is safe in any build).
+    // ns must already be loaded. Eager only where it EXISTS: its own `wasm/…` refs
+    // are likewise analyze-time, so the file is `wasm_only` and leaves ACTIVE_FILES
+    // (hence this eager set, which is only ever consulted per ACTIVE_FILES entry)
+    // in a build without `-Dwasm`.
     .{"cljw.wasm"},
 });
 
@@ -142,9 +156,11 @@ pub const FILES: []const FileEntry = &.{
     // clojure.test (FILES[10]) + clojure.stacktrace (FILES[19]). Appended last.
     .{ .label = "<clojure.test.tap>", .source = embedSrc("clj/clojure/test/tap.clj") },
     // cljw.wasm (W1, D-404) — require-a-component over the wasm/ primitives.
-    // Require-on-demand AND wasm-gated (the lookup below only serves it under
-    // `-Dwasm`, since the wasm/ ns it rides is absent otherwise). Appended last.
-    .{ .label = "<cljw.wasm>", .source = embedSrc("clj/cljw/wasm.clj") },
+    // Require-on-demand AND wasm-gated: `wasm_only` drops it from ACTIVE_FILES
+    // and from the lookup below in a build without `-Dwasm`. Its `wasm/…` call
+    // sites resolve at ANALYZE time, so a non-`-Dwasm` build cannot compile it
+    // at all — the file must leave every walk, not merely the resolver.
+    .{ .label = "<cljw.wasm>", .source = embedSrc("clj/cljw/wasm.clj"), .wasm_only = true },
     // clojure.spec.gen.alpha + clojure.spec.alpha — official stdlib (ships in
     // clojure.jar), so eager-bundled (the stdlib-eager / contrib-completeness
     // policy). gen loads FIRST (alpha `(:require clojure.spec.gen.alpha)`).
@@ -172,13 +188,28 @@ pub const FILES: []const FileEntry = &.{
     .{ .label = "<clojure.repl>", .source = embedSrc("clj/clojure/repl.clj") },
 };
 
+/// The build-active subset of `FILES`. **Every walk that compiles, emits, or
+/// replays bundled files iterates this, never `FILES`** — `FILES` keeps its
+/// full shape (and its stable indices) so `lookupEmbeddedFile` stays index-keyed.
+pub const ACTIVE_FILES: []const FileEntry = blk: {
+    var active: [FILES.len]FileEntry = undefined;
+    var n: usize = 0;
+    for (FILES) |file| {
+        if (!isActiveFile(file)) continue;
+        active[n] = file;
+        n += 1;
+    }
+    const frozen = active;
+    break :blk frozen[0..n];
+};
+
 /// The bundled `.clj` text for `label` (C5'-b). Raw mode (cache_gen)
 /// returns the embedded slice; the shipped cljw decompresses from the
 /// `bootstrap_sources` blob into `rt.load_arena` (session lifetime — the
 /// text backs SourceContext renders and source replays). Returns null for
 /// labels outside the bundled set.
 pub fn sourceText(rt: *Runtime, label: []const u8) ?[]const u8 {
-    for (FILES) |file| {
+    for (ACTIVE_FILES) |file| {
         if (!std.mem.eql(u8, file.label, label)) continue;
         if (file.source) |raw| return raw;
         break;
@@ -257,7 +288,8 @@ fn lookupEmbeddedFile(ns_name: []const u8) ?FileEntry {
     // cljw.wasm rides the `wasm/` primitive ns, which only exists in a `-Dwasm`
     // build — so it is resolvable only there (a non-wasm build reports the ns as
     // not found, honest, rather than failing on an unresolvable `wasm/…` later).
-    if (build_options.wasm and std.mem.eql(u8, ns_name, "cljw.wasm")) return FILES[23];
+    // The gate is `isActiveFile`, the SAME predicate ACTIVE_FILES uses.
+    if (std.mem.eql(u8, ns_name, "cljw.wasm")) return if (isActiveFile(FILES[23])) FILES[23] else null;
     if (std.mem.eql(u8, ns_name, "clojure.spec.gen.alpha")) return FILES[24];
     if (std.mem.eql(u8, ns_name, "clojure.spec.alpha")) return FILES[25];
     if (std.mem.eql(u8, ns_name, "clojure.core.specs.alpha")) return FILES[26];
@@ -305,8 +337,8 @@ pub fn loadCore(
     // ADR-0163: pre-register before the source files eval so each file's
     // intra-bootstrap `(:require other-bootstrap-lib)` is a loaded_libs no-op
     // (mirrors the AOT path; without it the new loadOrFindNs guard re-parses).
-    try markFilesLoaded(rt, FILES);
-    try loadCoreFiles(arena, rt, env, macro_table, FILES);
+    try markFilesLoaded(rt, ACTIVE_FILES);
+    try loadCoreFiles(arena, rt, env, macro_table, ACTIVE_FILES);
     try finalizeUserNs(rt, env);
 }
 
@@ -643,15 +675,15 @@ pub fn loadCoreAot(
     // (e.g. spec.alpha requires walk — both eager). Without this the loaded_libs
     // guard would re-parse. Run only the eager regions; every other ns replays from
     // its region on first `require` (loadOrFindNs → loadRegionNamespace).
-    for (FILES) |file| {
+    for (ACTIVE_FILES) |file| {
         const ns_name = nsNameFromLabel(file.label);
         if (isEagerNs(ns_name)) try markOneLoaded(rt, ns_name);
     }
     // v7 (ADR-0173): the blob-level shared constant pool — parsed once for
     // the whole eager set; lazy requires re-parse per replay (cheap slice walk).
     var blob_pool = try serialize.readBlobPool(rt.gpa, bootstrap_blob);
     defer if (blob_pool) |*cp| cp.deinit(rt.gpa);
-    for (FILES) |file| {
+    for (ACTIVE_FILES) |file| {
         const ns_name = nsNameFromLabel(file.label);
         if (!isEagerNs(ns_name)) continue;
         // A missing region means the embedded blob is malformed (build bug).
@@ -817,6 +849,33 @@ test "embeddedResolver returns null for unknown namespaces" {
     try testing.expect((try embeddedResolver(&rt, "clojure")) == null);
 }
 
+test "ACTIVE_FILES and lookupEmbeddedFile gate on the same predicate" {
+    // The non-wasm bootstrap break: cache_gen AOT-compiled every FILES entry
+    // while lookupEmbeddedFile refused to serve `cljw.wasm` without `-Dwasm`,
+    // so a build with the flag off died analysing a file it could never load
+    // ("No namespace: 'wasm'"). Both sides now read `isActiveFile`, and this
+    // test pins the coupling in EITHER build config — so the next gated file
+    // cannot be added to one walk and forgotten in the other.
+    //
+    // Only the INACTIVE direction is asserted: an active file need not be
+    // name-resolvable (`<clojure.core-meta>` and `<clojure.repl>` deliberately
+    // have no `lookupEmbeddedFile` row), but an inactive one must be absent
+    // from BOTH — that asymmetry is exactly what the break violated.
+    for (FILES) |file| {
+        if (isActiveFile(file)) continue;
+        // Inactive ⇒ unresolvable, and absent from the walked set.
+        try testing.expect(lookupEmbeddedFile(nsNameFromLabel(file.label)) == null);
+        for (ACTIVE_FILES) |active| {
+            try testing.expect(!std.mem.eql(u8, active.label, file.label));
+        }
+    }
+    // Exactly one gated file today; ACTIVE_FILES is FILES under `-Dwasm`.
+    try testing.expectEqual(
+        @as(usize, if (build_options.wasm) FILES.len else FILES.len - 1),
+        ACTIVE_FILES.len,
+    );
+}
+
 test "installEmbeddedResolver sets rt.require_resolver" {
     var th = std.Io.Threaded.init(testing.allocator, .{});
     defer th.deinit();
 
@@ -151,4 +151,33 @@ got_mo=$(cd "$TMP/empty" && "$TMP/mo" 7)
 [[ "$got_mo" == "via main-opts: [7]" ]] || fail "main_opts_drive: got '$got_mo', want 'via main-opts: [7]'"
 echo "PASS main_opts_drive -> via main-opts: [7]"
 
+# (12) BUILD-TIME stdout must survive a redirect to a REGULAR FILE. Build-time
+#      eval runs the entry's top-level forms (A1-D2), and buildArtifact left
+#      rt.stdout null, so each println built a fresh offset-tracking writer that
+#      restarted at offset 0 — on a seekable fd every form's output overwrote
+#      the previous one (5 forms landed as "5\n"). A pipe hid it (no seek), and
+#      every other case here captures through command substitution, so the whole
+#      file redirected the build to /dev/null and never saw it. Assert the FILE
+#      case explicitly: the same one process-shared writer fix as (4), build side.
+cat >"$TMP/btstdout.clj" <<'CLJ'
+(println 1)
+(println 2)
+(println 3)
+(println 4)
+(println 5)
+CLJ
+"$BIN" build "$TMP/btstdout.clj" -o "$TMP/btstdout" >"$TMP/btstdout.log" 2>&1
+got_bt=$(cat "$TMP/btstdout.log")
+want_bt=$'1\n2\n3\n4\n5'
+[[ "$got_bt" == "$want_bt" ]] || fail "buildtime_stdout_to_file: got '$got_bt', want '$want_bt'"
+echo "PASS buildtime_stdout_to_file -> 5 lines, ordered + complete"
+
+# (13) …and the built binary still prints the same 5 lines at RUN, to a file
+#      too. Pins that the build-side writer fix did not consume or reorder the
+#      payload's own run-time output.
+"$TMP/btstdout" >"$TMP/btstdout.run.log" 2>&1
+got_btrun=$(cat "$TMP/btstdout.run.log")
+[[ "$got_btrun" == "$want_bt" ]] || fail "buildtime_stdout_run: got '$got_btrun', want '$want_bt'"
+echo "PASS buildtime_stdout_run -> 5 lines at run too"
+
 echo "ALL phase14_cljw_build PASS"