worker-shell: redirected cat output and heredocs store non-ASCII bytes double-encoded (é becomes c3 83 c2 a9) #286

diff --git a/packages/computer/src/backends/worker-shell/adapter.test.ts b/packages/computer/src/backends/worker-shell/adapter.test.ts
index 2de3488..f5b3f1d 100644
--- a/packages/computer/src/backends/worker-shell/adapter.test.ts
+++ b/packages/computer/src/backends/worker-shell/adapter.test.ts
@@ -236,6 +236,28 @@ describe("WorkspaceFsAdapter — writes", () => {
     expect(await adapter.readlink("/link")).toBe("/target");
   });
 
+  it("writeFile and appendFile store a binary string as one byte per char", async () => {
+    // just-bash hands shell output to the filesystem as a byte string
+    // tagged "binary": "\xc3\xa9" is the UTF-8 encoding of é.
+    await adapter.writeFile("/b", "\xc3\xa9", "binary");
+    await adapter.appendFile("/b", "\xff\n", { encoding: "latin1" });
+    const back = new Uint8Array(
+      await new Response(await workspace.fs.readFile("/b")).arrayBuffer(),
+    );
+    expect(Array.from(back)).toEqual([0xc3, 0xa9, 0xff, 0x0a]);
+  });
+
+  it("keeps non-ASCII bytes when the shell redirects cat, a heredoc or tee", async () => {
+    const bash = new Bash({ fs: adapter as never, cwd: "/" });
+    const result = await bash.exec(
+      "cat > /h <<'EOF'\né\nEOF\ncat /h > /c; cat /h >> /a; cat /h | tee /t >/dev/null",
+    );
+    expect(result).toMatchObject({ exitCode: 0, stderr: "" });
+    for (const path of ["/h", "/c", "/a", "/t"]) {
+      expect(await workspace.fs.readFile(path, "utf8")).toBe("é\n");
+    }
+  });
+
   it("discards shell redirection writes to /dev/null", async () => {
     const bash = new Bash({ fs: adapter as never, cwd: "/" });
     const result = await bash.exec("printf hello >/dev/null && cat /dev/null");
diff --git a/packages/computer/src/backends/worker-shell/adapter.ts b/packages/computer/src/backends/worker-shell/adapter.ts
index 2d857fb..716fadc 100644
--- a/packages/computer/src/backends/worker-shell/adapter.ts
+++ b/packages/computer/src/backends/worker-shell/adapter.ts
@@ -74,6 +74,7 @@ interface DirentEntry {
 }
 
 type AdapterReadFileOptions = { encoding?: "utf8" | null } | "utf8" | null | undefined;
+type AdapterWriteFileOptions = { encoding?: string | null } | string | null | undefined;
 
 export class WorkspaceFsAdapter {
   readonly #fs: WorkspaceFs;
@@ -149,12 +150,20 @@ export class WorkspaceFsAdapter {
 
   // --- Writes ------------------------------------------------------
 
-  async writeFile(path: string, content: string | Uint8Array, _options?: unknown): Promise<void> {
+  async writeFile(
+    path: string,
+    content: string | Uint8Array,
+    options?: AdapterWriteFileOptions,
+  ): Promise<void> {
     if (isDevNull(path)) return;
-    await this.#fs.writeFile(path, content);
+    await this.#fs.writeFile(path, binaryContent(content, options));
   }
 
-  async appendFile(path: string, content: string | Uint8Array, _options?: unknown): Promise<void> {
+  async appendFile(
+    path: string,
+    content: string | Uint8Array,
+    options?: AdapterWriteFileOptions,
+  ): Promise<void> {
     if (isDevNull(path)) return;
     let existing: Uint8Array;
     try {
@@ -164,7 +173,8 @@ export class WorkspaceFsAdapter {
       if ((err as { code?: string }).code !== "ENOENT") throw err;
       existing = new Uint8Array(0);
     }
-    const addition = typeof content === "string" ? new TextEncoder().encode(content) : content;
+    const data = binaryContent(content, options);
+    const addition = typeof data === "string" ? new TextEncoder().encode(data) : data;
     const out = new Uint8Array(existing.byteLength + addition.byteLength);
     out.set(existing, 0);
     out.set(addition, existing.byteLength);
@@ -280,6 +290,23 @@ function missingPath(path: string): Error & { code: string; path: string } {
   return error;
 }
 
+// just-bash writes shell output (redirections, tee) as a byte string
+// tagged "binary": each char is one byte, so UTF-8 text arrives
+// already encoded. Pass those bytes through; only an untagged or
+// "utf8" string is text for the store to encode.
+function binaryContent(
+  content: string | Uint8Array,
+  options: AdapterWriteFileOptions,
+): string | Uint8Array {
+  const encoding = typeof options === "string" ? options : options?.encoding;
+  if (typeof content !== "string" || (encoding !== "binary" && encoding !== "latin1")) {
+    return content;
+  }
+  const bytes = new Uint8Array(content.length);
+  for (let i = 0; i < content.length; i++) bytes[i] = content.charCodeAt(i);
+  return bytes;
+}
+
 function mapStat(s: WorkspaceStatResult): FsStat {
   return {
     isFile: s.isFile,