library: the envelope — one packet shape for every protocol

A protocol is now defined through envelope.Define rather than beside it.
Every packet begins with the same 16-byte prefix: a Header of {operation,
target} for a request or event, a Status for a reply. The header is folded
into each protocol's own layout, never stacked on top of it — Define walks
a spec's types and refuses one that carries a Header or Status field, so
the rule cannot be missed by reading. Operations number from 16, leaving
describe, enumerate, subscribe and unsubscribe reserved and answerable the
same way everywhere; describe the envelope answers itself, and an unknown
verb is -ENOSYS without a provider writing a line.

The size floor becomes something protocols can compile against: 256 bytes
for a call, 64 for a push, matching the kernel's own limits, checked at the
Define call with the prefix counted in. A protocol that outgrows either
fails the build with the reason and the remedy — shrink, or move the bulk
to shared memory, because packets never fragment. Events carry the header
too and number in their own space, so appending an operation can never
renumber a shipped event.

Beside it, the client half of the model: a Channel is what opening a
/protocol name yields, wrapping the endpoint capability so a program holds
a conversation rather than a handle. Nothing speaks through either yet —
the vfs protocol gains NodeKind.protocol and the convention that an open
reply may carry a capability, and that is the whole runtime change.

Suite 107/107, unchanged: P1 converts nothing.

library/kernel/build.zig

@@ -52,7 +52,7 @@ pub fn build(b: *std.Build) void {
             .{ .name = "time", .module = time },
         },
     });
-    _ = b.addModule("file-system", .{
+    const file_system = b.addModule("file-system", .{
         .root_source_file = b.path("file-system.zig"),
         .imports = &.{
             .{ .name = "abi", .module = abi },
@@ -61,6 +61,19 @@ pub fn build(b: *std.Build) void {
             .{ .name = "vfs-protocol", .module = protocol.module("vfs-protocol") },
         },
     });
+    // The channel is the L1 concept made concrete (docs/os-development/communication.md):
+    // it needs the namespace (file-system, to resolve a /protocol name) and the
+    // transport (ipc) both, which is why it lives here rather than in a protocol
+    // module — those import nothing.
+    _ = b.addModule("channel", .{
+        .root_source_file = b.path("channel.zig"),
+        .imports = &.{
+            .{ .name = "ipc", .module = ipc },
+            .{ .name = "file-system", .module = file_system },
+            .{ .name = "vfs-protocol", .module = protocol.module("vfs-protocol") },
+            .{ .name = "envelope", .module = protocol.module("envelope") },
+        },
+    });
     _ = b.addModule("memory", .{
         .root_source_file = b.path("memory/memory.zig"),
         .imports = &.{
@@ -101,4 +114,21 @@ pub fn build(b: *std.Build) void {
         });
         test_step.dependOn(&b.addRunArtifact(kernel_tests).step);
     }
+
+    // channel needs its whole import set to compile at all; only its framing is
+    // host-runnable (the syscall seams are x86_64-only, and unreferenced from
+    // the tests), so that is what it tests.
+    const channel_tests = b.addTest(.{
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("channel.zig"),
+            .target = b.resolveTargetQuery(.{}),
+            .imports = &.{
+                .{ .name = "ipc", .module = ipc },
+                .{ .name = "file-system", .module = file_system },
+                .{ .name = "vfs-protocol", .module = protocol.module("vfs-protocol") },
+                .{ .name = "envelope", .module = protocol.module("envelope") },
+            },
+        }),
+    });
+    test_step.dependOn(&b.addRunArtifact(channel_tests).step);
 }