@webinson/peer 0.4.22 → 0.4.24

package/README.md

@@ -14,7 +14,9 @@ and the commands `/peer` and `/peer-list` in `~/.claude/commands`.
 
 In a Claude Code thread:
 
-- `/peer` shares this thread in your workspace.
+- `/peer` shares this thread in your workspace. Its turn only confirms the sharing and carries no memory at all,
+  so a thread you then switch to Jellyfish holds none from the start.
+- `/peer jellyfish` and `/peer elephant` share it in that memory mode at once.
 - `/peer <message>` shares it and passes the message on to the agent as your prompt.
 - `/peer stop` ends sharing. Quitting or restarting Claude Code only pauses it: the thread shows as stopped and
   is shared again when the session is resumed. `/clear` and signing out of Claude Code end it.
@@ -25,7 +27,9 @@ In a Claude Code thread:
     thread goes, on top of Claude Code's own memory. It saves only the turns from the moment it was chosen.
   - **Inactive** (not shared): Claude Code's own memory alone; PeerMemory stays off.
   - **Use Jellyfish** (shared): no memory at all, neither PeerMemory nor Claude Code's own (`MEMORY.md`).
-    `CLAUDE.md` instructions stay.
+    The agent cannot read, search or change Claude Code's memory files with a tool either.
+    `CLAUDE.md` instructions stay. Claude Code puts `MEMORY.md` into a thread's first message, so a thread meant to
+    hold none starts with `/peer` (or `/peer jellyfish`): a first message with work in it already carries it.
 
   Pressing the lit mode again stops sharing (Inactive); pressing either while Inactive shares again. Every thread
   that is not shared runs without OpenViking. What a thread was already given stays in it after a switch. The
@@ -99,11 +103,11 @@ peer-codex
 If you already signed in to Peer, use `peer install --codex --client` in place of the login
 command. Review and trust the Peer Thread Mark hooks in Codex's `/hooks` menu.
 
-The `--client` setup needs Git, Rust/Cargo, `curl`, `shasum`, and a C/C++ toolchain on
-the machine. It builds the pinned Codex client under `~/.peer/codex-client`. If you already
-built it, set `PEER_CODEX_CLIENT` to its executable when you run setup. The `peer-codex`
-launcher uses your existing Codex settings and sign-in with its own app server. `PEER_HOME`
-moves the default checkout and Peer state.
+The `--client` setup downloads the matching prebuilt client from npm into
+`~/.peer/codex-clients`. It supports macOS, Linux, and Windows on x64 and ARM64,
+and requires Node.js and npm. Set `PEER_CODEX_CLIENT` to use a custom build.
+The `peer-codex` launcher uses your existing Codex settings and sign-in with its
+own app server. `PEER_HOME` moves the client cache and Peer state.
 
 For the plugin alone, omit `--client`. The Codex plugin lives under [`mod/codex`](mod/codex)
 in its own marketplace.
@@ -113,8 +117,7 @@ In stock Codex, send `peer: start`, `peer: stop`, `peer: list`, `peer: thread`,
 This plugin uses the [Codex hook API](https://learn.chatgpt.com/docs/hooks); stock Codex does
 not expose a composer band or memory switches to plugins.
 
-From a source checkout, use `node bin/peer.mjs install --codex --client` and
-`bash mod/codex/client/run.sh` from `cli/`.
+For a custom build, see [building the client](mod/codex/client/README.md).
 
 The terminal band shows the thread's memory count, **Use Elephant**, **Use Jellyfish**, and
 **Active** or **Inactive**. Press the lit mode again to stop sharing. Use `/peer-mode` for

package/bin/codex-native.mjs

@@ -0,0 +1,73 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+export const codexTargets = {
+  "darwin-arm64": "aarch64-apple-darwin",
+  "darwin-x64": "x86_64-apple-darwin",
+  "linux-arm64": "aarch64-unknown-linux-musl",
+  "linux-x64": "x86_64-unknown-linux-musl",
+  "win32-arm64": "aarch64-pc-windows-msvc",
+  "win32-x64": "x86_64-pc-windows-msvc",
+};
+
+export const codexPackageName = (platform) => `@webinson/peer-codex-${platform}`;
+export const codexExecutable = (platform) => platform === "win32" ? "codex.exe" : "codex";
+export const codexNativeVersion = "0.4.18";
+
+function installedClient(directory, target) {
+  const bin = path.join(directory, "vendor", target, "bin");
+  const suffix = process.platform === "win32" ? ".exe" : "";
+  const client = path.join(bin, codexExecutable(process.platform));
+  try {
+    for (const executable of [client, path.join(bin, `codex-code-mode-host${suffix}`)]) {
+      if (!fs.statSync(executable).isFile()) return null;
+      fs.accessSync(executable, fs.constants.X_OK);
+    }
+    return client;
+  } catch {
+    return null;
+  }
+}
+
+export function installNativeCodex(peer) {
+  const platform = `${process.platform}-${process.arch}`;
+  const target = codexTargets[platform];
+  if (!target) {
+    throw new Error(`No prebuilt Peer Codex for ${platform}. Set PEER_CODEX_CLIENT to a custom build.`);
+  }
+  const packageName = codexPackageName(platform);
+  const spec = `${packageName}@${codexNativeVersion}`;
+  const root = path.resolve(peer.home, "codex-clients");
+  const destination = path.join(root, `${platform}-${codexNativeVersion}`);
+  if (fs.existsSync(destination)) {
+    const existing = installedClient(destination, target);
+    if (existing) return existing;
+    throw new Error(`Incomplete Peer Codex install at ${destination}. Remove that directory and retry.`);
+  }
+
+  fs.mkdirSync(root, { recursive: true, mode: 0o700 });
+  const staging = fs.mkdtempSync(path.join(root, ".install-"));
+  try {
+    const args = [
+      "install", "--prefix", ".", "--global=false", "--ignore-scripts",
+      "--no-save", "--no-package-lock", "--no-audit", "--no-fund", spec,
+    ];
+    const options = { cwd: staging, stdio: "inherit", timeout: 600_000 };
+    if (process.platform === "win32") {
+      execFileSync(process.env.ComSpec || "cmd.exe", ["/d", "/c", "npm", ...args], options);
+    } else {
+      execFileSync("npm", args, options);
+    }
+    const downloaded = path.join(staging, "node_modules", packageName);
+    if (!installedClient(downloaded, target)) throw new Error(`${spec} is missing its executables`);
+    try {
+      fs.renameSync(downloaded, destination);
+    } catch (error) {
+      if (!installedClient(destination, target)) throw error;
+    }
+    return installedClient(destination, target);
+  } finally {
+    fs.rmSync(staging, { recursive: true, force: true });
+  }
+}

package/bin/codex-thread-mark.mjs

@@ -1,6 +1,7 @@
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
+import { installNativeCodex } from "./codex-native.mjs";
 
 // Codex's lifecycle hooks use their own event and output shapes. Keep Claude's
 // title updates and UI out of this adapter.
@@ -21,14 +22,13 @@ export function installCodex(peer, { client = false } = {}) {
       fs.accessSync(clientPath, fs.constants.X_OK);
       if (!fs.statSync(clientPath).isFile()) throw new Error("PEER_CODEX_CLIENT must point to the Codex executable");
     } else {
-      const checkout = path.resolve(peer.home, "codex-client");
-      execFileSync("bash", [path.join(marketplace, "client", "build.sh"), checkout], { stdio: "inherit" });
-      clientPath = path.join(checkout, "codex-rs", "target", "debug", "codex");
+      clientPath = installNativeCodex(peer);
     }
   }
 
   const binary = process.env.PEER_CODEX || (client ? clientPath : "codex");
-  const runCodex = (args, capture = false) => codex(args, { binary, capture });
+  const timeout = client ? 300_000 : 60_000;
+  const runCodex = (args, capture = false) => codex(args, { binary, capture, timeout });
   const listed = runCodex(["plugin", "marketplace", "list", "--json"], true);
   const previous = JSON.parse(listed).marketplaces?.find((item) => item.name === MARKETPLACE);
   const moving = previous && previous.root !== marketplace;
@@ -65,11 +65,11 @@ export function uninstallCodex(peer) {
   console.log("Codex: Peer's plugin removed.");
 }
 
-function codex(args, { binary, capture = false }) {
+function codex(args, { binary, capture = false, timeout = 60_000 }) {
   return execFileSync(binary, args, {
     stdio: capture ? ["ignore", "pipe", "inherit"] : "inherit",
     encoding: "utf8",
-    timeout: 60_000,
+    timeout,
   });
 }
 

package/bin/peer-codex.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { codexExecutable } from "./codex-native.mjs";
+
+const home = process.env.PEER_HOME || path.join(os.homedir(), ".peer");
+let configured;
+try {
+  configured = JSON.parse(fs.readFileSync(path.join(home, "codex-cli.json"), "utf8"))?.client;
+} catch {}
+const client = process.env.PEER_CODEX_CLIENT
+  || (typeof configured === "string" && path.isAbsolute(configured) ? configured : null)
+  || path.join(home, "codex-client", "codex-rs", "target", "debug", codexExecutable(process.platform));
+try {
+  fs.accessSync(client, fs.constants.X_OK);
+} catch {
+  console.error("Set up the Peer Codex terminal with peer install --codex --client.");
+  process.exit(1);
+}
+
+// A stock daemon would use the stock memory policy.
+const args = ["--no-daemon", ...process.argv.slice(2)];
+const env = { ...process.env, PEER_CODEX_THREAD_MARK: "1" };
+if (process.platform !== "win32" && typeof process.execve === "function") {
+  process.on("SIGXFSZ", () => {});
+  process.execve(client, [client, ...args], env);
+}
+
+const child = spawn(client, args, { stdio: "inherit", env });
+const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+const forward = (signal) => {
+  if (!child.killed) child.kill(signal);
+};
+for (const signal of signals) process.on(signal, forward);
+child.on("error", (error) => {
+  console.error(`Could not start Peer Codex: ${error.message}`);
+  process.exitCode = 1;
+});
+child.on("exit", (code, signal) => {
+  for (const name of signals) process.off(name, forward);
+  process.exitCode = code ?? (signal ? 128 + os.constants.signals[signal] : 1);
+  if (signal && process.platform !== "win32") process.kill(process.pid, signal);
+});

package/bin/peer.mjs

@@ -46,12 +46,12 @@ const HELP = `peer: share chosen agent threads with your team
                     your own memories in your personal OpenViking, or the ones with these words
                     (full text); here: only this repository's. /peer-all in Claude Code
   peer install [--codex [--client]]
-                    set up the thread mark; --client also builds the Peer Codex terminal
+                    set up the thread mark; --client also installs the Peer Codex terminal
   peer uninstall [--codex]  remove the integration from Claude Code or Codex
   peer logout       forget the sign-in on this computer
 
-In Claude Code: /peer shares the thread (/peer <message> also sends the message on), /peer stop
-ends it, /peer-list shows the list.
+In Claude Code: /peer shares the thread (/peer <message> also sends the message on, /peer jellyfish
+or /peer elephant picks its memory mode), /peer stop ends it, /peer-list shows the list.
 Only threads where /peer was typed are shared, and only their repository, branch, state and the
 paths of the files they edit: never prompts, answers, summaries or file contents.`;
 
@@ -307,13 +307,16 @@ async function hook(event) {
       if (argument === "stop") {
         return block(await stopSharing(saved, session, input.cwd), retitle(input, false));
       }
+      // `/peer jellyfish` and `/peer elephant` share it like a bare /peer; the band's mod takes the mode from them.
+      const mode = /^(jellyfish|elephant)$/i.exec(argument)?.[1]?.toLowerCase();
+      const message = mode ? "" : argument;
       // `/peer <message>` shares the thread and lets the message through: the command hands it to the model.
-      const { said, what } = await shareThread(saved, session, input.cwd, Boolean(argument));
+      const { said, what } = await shareThread(saved, session, input.cwd, Boolean(message));
       const sessionTitle = retitle(input, true, what);
       // A bare /peer reaches the agent too, which confirms in one line: a block would show the person Claude
       // Code's "hook blocked your prompt" warning for what went right.
-      const note = argument ? said : `${said}\n${ALONE_NOTE}`;
-      log(argument ? "answered /peer with a message: shared, message passed on" : "answered /peer: shared, the agent confirms");
+      const note = message ? said : `${said}\n${mode ? MODE_NOTE(mode) : ALONE_NOTE}`;
+      log(message ? "answered /peer with a message: shared, message passed on" : `answered /peer${mode ? ` ${mode}` : ""}: shared, the agent confirms`);
       return answer({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: `${SHARED_NOTE}\n${note}`, ...(sessionTitle ? { sessionTitle } : {}) } });
     }
     if (shared) await reportQuietly(session, "working", input.cwd);
@@ -366,10 +369,14 @@ const SHARED_NOTE = "[Peer's hook ran]";
 const ALONE_NOTE =
   "The person typed /peer alone. Reply with only that confirmation, in one or two short lines in the person's language: where the thread is shared, that teammates see its repository, branch, state and the paths of the files it edits but never the conversation, and that /peer stop ends it. Do nothing else and use no tools.";
 
+// `/peer jellyfish` or `/peer elephant`: the same confirmation, with the mode the thread now uses.
+const MODE_NOTE = (mode) =>
+  `The person typed /peer ${mode}: it picks the thread's memory mode and is not a message to work on. Reply with only that confirmation, in one or two short lines in the person's language: where the thread is shared, that teammates see its repository, branch, state and the paths of the files it edits but never the conversation, that the thread uses ${mode === "jellyfish" ? "Jellyfish (no memory)" : "Elephant (PeerMemory and Claude Code's own memory)"}, and that /peer stop ends it. Do nothing else and use no tools.`;
+
 const COMMAND_FILES = {
   "peer.md": `---
-description: Share this thread on Peer (/peer), share it and go on (/peer <message>), or stop sharing it (/peer stop)
-argument-hint: "[message | stop]"
+description: Share this thread on Peer (/peer), with a memory mode (/peer jellyfish, /peer elephant), share it and go on (/peer <message>), or stop sharing it (/peer stop)
+argument-hint: "[message | jellyfish | elephant | stop]"
 ---
 $ARGUMENTS
 

package/mod/codex/client/README.md

@@ -1,8 +1,9 @@
 # Peer for the Codex terminal
 
 The sibling Codex plugin can report thread activity and answer commands with stock Codex.
-`build.sh` builds the terminal client for the band, local panels, and per-thread memory policy.
-`run.sh` keeps the terminal on its own app server so it uses that policy.
+`peer install --codex --client` installs the native npm package for the current OS and
+architecture. `peer-codex` runs that client with its own app server so it uses the
+Peer memory policy.
 
 `src/` contains the Peer modules. The two patches wire them into the pinned Codex source:
 `0001-memory.patch` controls plugin availability, capture and native memory; `0002-terminal.patch`
@@ -12,9 +13,32 @@ capture windows. Update the Codex pin, V8 version, checksums and patches togethe
 The patches include context from OpenAI Codex, distributed under Apache-2.0.
 See [CODEX-LICENSE](CODEX-LICENSE) and [CODEX-NOTICE](CODEX-NOTICE).
 
-From the repository root, run `npm test --prefix cli`. To exercise the actual band, switches,
-and panels with temporary profiles and local fixture servers, run:
+## Building and packing a release
+
+`build.sh` takes the path of a checkout to create or reuse. It needs Git, Rust/Cargo,
+`curl`, `shasum`, and a C/C++ toolchain. For a custom build, run it and set
+`PEER_CODEX_CLIENT` to the resulting executable when running `peer install --codex --client`.
+
+Set `PEER_CODEX_BUILD_PROFILE=release` for an npm build and set
+`CARGO_PROFILE_RELEASE_STRIP=symbols` before compiling. Set `PEER_CODEX_BUILD_TARGET`
+to build for a specific Rust target with the matching Rust standard library and C toolchain.
+For cross-compiling, `PEER_CODEX_CARGO_COMMAND` can select `zigbuild` or `xwin`.
+For Linux musl builds, use the pinned upstream release's musl tools and set
+`CODEX_BWRAP_SHA256` to the SHA-256 of the `codex-resources/bwrap` shipped in the
+matching upstream npm package before compiling.
+
+After building, run:
 
 ```bash
-python3 cli/test/codex-client-smoke.py /path/to/codex
+bash pack.sh darwin-arm64 /path/to/build/bin /path/to/codex-checkout /path/to/output
 ```
+
+Use the directory containing both `codex` and `codex-code-mode-host` (with `.exe` on
+Windows). The script adds the matching upstream sandbox and search helpers. Build and
+pack `darwin-arm64`, `darwin-x64`, `linux-arm64`, `linux-x64`, `win32-arm64`, and
+`win32-x64` for a native release. The installer pins their version in
+`bin/codex-native.mjs`. When that pin changes, publish and verify the native packages
+before publishing the version of `@webinson/peer` that uses them.
+
+From the repository root, run `npm test --prefix cli`. The band, switches and panels have no
+automated check yet; try them by hand in `peer-codex`.

package/mod/codex/client/build.sh

@@ -39,20 +39,34 @@ if [[ -n ${PEER_CODEX_TOOLCHAIN:-} ]]; then
 fi
 cd -- "$checkout/codex-rs"
 # The pinned Codex release ships its V8 build on the Codex release, not on denoland's.
-host=$(rustc ${cargo_args[@]+"${cargo_args[@]}"} -vV | awk '/^host:/ {print $2}')
+target=${PEER_CODEX_BUILD_TARGET:-$(rustc ${cargo_args[@]+"${cargo_args[@]}"} -vV | awk '/^host:/ {print $2}')}
+profile=${PEER_CODEX_BUILD_PROFILE:-dev}
+build_args=(--profile "$profile")
+cargo_command=("${PEER_CODEX_CARGO_COMMAND:-build}")
+if [[ "${cargo_command[0]}" == xwin ]]; then
+  cargo_command+=(build)
+fi
+target_dir=${CARGO_TARGET_DIR:-"$checkout/codex-rs/target"}
+output="$target_dir"
+if [[ -n ${PEER_CODEX_BUILD_TARGET:-} ]]; then
+  build_args+=(--target "$target")
+  output="$output/$target"
+fi
 v8=152.2.0
-v8_dir="$checkout/target/peer-v8/$host"
+v8_dir="$checkout/target/peer-v8/$target"
 v8_base="https://github.com/openai/codex/releases/download/rusty-v8-v$v8"
-binding="src_binding_ptrcomp_sandbox_release_${host}.rs"
-archive="librusty_v8_ptrcomp_sandbox_release_${host}.a.gz"
-if [[ "$host" == *-pc-windows-msvc ]]; then
-  archive="rusty_v8_ptrcomp_sandbox_release_${host}.lib.gz"
+binding="src_binding_ptrcomp_sandbox_release_${target}.rs"
+archive="librusty_v8_ptrcomp_sandbox_release_${target}.a.gz"
+exe=""
+if [[ "$target" == *-pc-windows-msvc ]]; then
+  archive="rusty_v8_ptrcomp_sandbox_release_${target}.lib.gz"
+  exe=".exe"
 fi
 mkdir -p -- "$v8_dir"
 for artifact in "$archive" "$binding"; do
   checksum=$(awk -v file="$artifact" '$2 == file {print $1}' "$checkout/third_party/v8/rusty_v8_${v8//./_}.sha256")
   if [[ -z "$checksum" ]]; then
-    printf 'No pinned Codex V8 artifact for %s.\n' "$host" >&2
+    printf 'No pinned Codex V8 artifact for %s.\n' "$target" >&2
     exit 1
   fi
   if ! (cd -- "$v8_dir" && printf '%s  %s\n' "$checksum" "$artifact" | shasum -a 256 -c - >/dev/null 2>&1); then
@@ -62,6 +76,7 @@ for artifact in "$archive" "$binding"; do
 done
 # The upstream release tag changes workspace versions without regenerating Cargo.lock.
 RUSTY_V8_ARCHIVE="$v8_dir/$archive" RUSTY_V8_SRC_BINDING_PATH="$v8_dir/$binding" \
-  CARGO_PROFILE_DEV_DEBUG=0 cargo ${cargo_args[@]+"${cargo_args[@]}"} build \
-  --target-dir "$checkout/codex-rs/target" -p codex-cli -p codex-code-mode-host --bins
-printf 'Run with: PEER_CODEX_CLIENT=%q bash %q\n' "$checkout/codex-rs/target/debug/codex" "$here/run.sh"
+CARGO_PROFILE_DEV_DEBUG=0 cargo ${cargo_args[@]+"${cargo_args[@]}"} "${cargo_command[@]}" \
+  "${build_args[@]}" --target-dir "$target_dir" -p codex-cli -p codex-code-mode-host --bins
+[[ "$profile" != dev ]] || profile=debug
+printf 'Run with: PEER_CODEX_CLIENT=%q peer-codex\n' "$output/$profile/codex$exe"

package/mod/codex/client/pack.sh

@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+here=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)
+cli=$(cd -- "$here/../../.." && pwd)
+platform=${1:?usage: pack.sh PLATFORM BUILD_BIN_DIR CODEX_CHECKOUT OUTPUT_DIR}
+build=$(cd -- "${2:?missing build bin directory}" && pwd)
+source=$(cd -- "${3:?missing pinned Codex checkout}" && pwd)
+mkdir -p -- "${4:?missing output directory}"
+output=$(cd -- "$4" && pwd)
+target=$(node --input-type=module - "$cli" "$platform" <<'JS'
+import { pathToFileURL } from "node:url";
+import path from "node:path";
+const { codexTargets } = await import(pathToFileURL(path.join(process.argv[2], "bin/codex-native.mjs")));
+const target = codexTargets[process.argv[3]];
+if (!target) throw new Error("Unsupported Peer Codex platform");
+console.log(target);
+JS
+)
+
+commit=f79b26ccbb3116b052544666a181012fb45dc49b
+codex_version=0.166.0-alpha.5.1
+[[ $(git -C "$source" rev-parse HEAD) == "$commit" ]]
+stage=$(mktemp -d "${TMPDIR:-/tmp}/peer-codex-pack.XXXXXXXX")
+trap 'rm -rf -- "$stage"' EXIT
+archive=$(npm pack "@openai/codex@$codex_version-$platform" --ignore-scripts --pack-destination "$stage" --silent)
+suffix=""
+resources=()
+case "$platform" in
+  linux-*) resources+=(codex-resources/bwrap) ;;
+  win32-*)
+    suffix=.exe
+    resources+=(codex-resources/codex-command-runner.exe codex-resources/codex-windows-sandbox-setup.exe)
+    ;;
+esac
+vendor="package/vendor/$target"
+assets=("$vendor/codex-package.json" "$vendor/codex-path/rg$suffix")
+for asset in ${resources[@]+"${resources[@]}"}; do assets+=("$vendor/$asset"); done
+tar -xf "$stage/$archive" -C "$stage" "${assets[@]}"
+mkdir -p "$stage/$vendor/bin"
+for binary in codex codex-code-mode-host; do
+  install -m 755 "$build/$binary$suffix" "$stage/$vendor/bin/$binary$suffix"
+done
+cp "$here/CODEX-LICENSE" "$stage/package/LICENSE"
+cp "$here/CODEX-NOTICE" "$stage/package/NOTICE"
+curl -fsSL --retry 2 'https://raw.githubusercontent.com/BurntSushi/ripgrep/15.2.0/LICENSE-MIT' \
+  -o "$stage/package/RIPGREP-LICENSE"
+if [[ "$platform" == linux-* ]]; then
+  cp "$source/codex-rs/vendor/bubblewrap/LICENSE" "$stage/package/BUBBLEWRAP-LICENSE"
+fi
+cat >> "$stage/package/NOTICE" <<EOF
+
+Peer Codex modifies the terminal UI, thread sharing and memory policy.
+Upstream source: https://github.com/openai/codex/tree/$commit
+The matching @webinson/peer npm package contains the Peer changes.
+
+The bundled ripgrep is from https://github.com/BurntSushi/ripgrep/tree/15.2.0.
+Linux bundles include the sandbox helper built from the Codex source above
+under codex-rs/vendor/bubblewrap. The corresponding sources and build scripts
+are in that same tree.
+EOF
+node --input-type=module - "$cli" "$platform" "$stage/package" <<'JS'
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+const [cli, platform, stage] = process.argv.slice(2);
+const [os, cpu] = platform.split("-");
+const { codexPackageName, codexNativeVersion } = await import(pathToFileURL(path.join(cli, "bin/codex-native.mjs")));
+const pkg = {
+  name: codexPackageName(platform),
+  version: codexNativeVersion,
+  description: `Peer Codex terminal for ${os} ${cpu}. Installed by @webinson/peer.`,
+  license: "Apache-2.0",
+  os: [os],
+  cpu: [cpu],
+  files: ["vendor", "NOTICE", "*-LICENSE"],
+};
+fs.writeFileSync(path.join(stage, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
+JS
+npm pack "$stage/package" --pack-destination "$output" --ignore-scripts

package/mod/codex/client/run.sh

@@ -1,22 +1,5 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-peer_root=${PEER_HOME:-"$HOME/.peer"}
-client=${PEER_CODEX_CLIENT:-}
-if [[ -z "$client" && -f "$peer_root/codex-cli.json" ]]; then
-  client=$(node -e '
-    try {
-      const data = JSON.parse(require("node:fs").readFileSync(process.argv[1], "utf8"));
-      if (typeof data.client === "string" && require("node:path").isAbsolute(data.client)) {
-        process.stdout.write(data.client);
-      }
-    } catch {}
-  ' "$peer_root/codex-cli.json")
-fi
-client=${client:-"$peer_root/codex-client/codex-rs/target/debug/codex"}
-if [[ ! -x "$client" ]]; then
-  printf 'Set up the Peer Codex terminal with peer install --codex --client.\n' >&2
-  exit 1
-fi
-# An existing stock daemon would use the stock memory policy.
-PEER_CODEX_THREAD_MARK=1 exec "$client" --no-daemon "$@"
+here=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)
+exec node "$here/../../../bin/peer-codex.mjs" "$@"

package/mod/peer-thread-mark/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "peer-thread-mark",
-  "version": "0.4.22",
+  "version": "0.4.24",
   "description": "Marks a Claude Code thread shared with Peer (/peer) with a band above the prompt, with /peer stop and /peer start; panes for /peer-list, /peer-thread and /peer-all (search your memories)",
   "license": "MIT",
   "types": "./types/index.d.ts"

package/mod/peer-thread-mark/hooks/register.tsx

@@ -212,7 +212,11 @@ async function refresh($: EngineInterface) {
 // Which memory a thread works with. Elephant (shared) adds OpenViking, its recall and its saving, to Claude Code's own
 // memory; Inactive keeps Claude Code's own memory alone; Jellyfish (shared) keeps none at all.
 type MemoryMode = 'openviking' | 'own' | 'none'
+// The turn of a /peer with no message (or only a mode) only confirms the sharing, so it carries no memory at all:
+// the person picks the thread's mode after it, and a Jellyfish picked then finds nothing in the thread already.
+let confirming = false
 async function memoryUse($: EngineInterface): Promise<MemoryMode> {
+  if (confirming) return 'none'
   if (!(await read($, shared))?.isShared) return 'own'
   return (await read($, mode)) === 'elephant' ? 'openviking' : 'none'
 }
@@ -272,6 +276,9 @@ async function applyMemory($: EngineInterface) {
 // What OpenViking's recall and Peer's team memory add to a prompt, left out where the thread keeps OpenViking off.
 const OPENVIKING_BLOCK = /<openviking-context|<teammates-project-knowledge/
 const OPENVIKING_TOOL = 'mcp__plugin_openviking-memory_'
+// Claude Code's own memory files, in a tool's input however it is written: a path, a glob, a shell command that
+// changes into ~/.claude first or looks for MEMORY.md there. A call that names both is held back.
+const usesMemoryFiles = (input: string) => /\.claude(?=[\\/"'\s]|$)/.test(input) && /memory/i.test(input)
 
 // The memory badge's color: an explicit value, as a surface may not know a theme key; it reads on light and dark.
 const SAVED_COLOR = '#8b5cf6'
@@ -576,6 +583,15 @@ export const register: Register = on => {
 
   // The CLI's prompt hook writes or removes the marker while a typed command goes in, so look after it.
   on('prompt.submit', async ($, e, next) => {
+    // `/peer`, `/peer jellyfish` or `/peer elephant`: a confirming turn, with the mode it names for the turns after.
+    const peer = e.command && /^(?:.+:)?peer$/.test(e.command.name) ? e.command.args.trim().toLowerCase() : undefined
+    const wasConfirming = confirming
+    confirming = peer === '' || peer === 'jellyfish' || peer === 'elephant'
+    if (peer === 'jellyfish' || peer === 'elephant') await update($, mode, () => peer)
+    if (confirming !== wasConfirming) {
+      $.ui.invalidate('prompt.section')
+      $.ui.invalidate('prompt.context')
+    }
     const result = await next(e)
     await update($, collideOff, () => false)
     await refresh($).catch(() => {})
@@ -671,6 +687,12 @@ export const register: Register = on => {
   })
 
   on('turn.complete', async ($, e, next) => {
+    // The confirming turn is over: from here on the thread's mode decides, so a press on the band reads it.
+    if (confirming) {
+      confirming = false
+      $.ui.invalidate('prompt.section')
+      $.ui.invalidate('prompt.context')
+    }
     await refresh($).catch(() => {})
     // OpenViking saves a thread's memories when a turn ends past its threshold, so the open pane and the Saved lines
     // under the thread's messages look again.
@@ -692,6 +714,11 @@ export const register: Register = on => {
     if (e.tool.startsWith(OPENVIKING_TOOL) && (await memoryUse($)) !== 'openviking') {
       return { deny: 'PeerMemory is off in this thread. Use Elephant turns it on.' }
     }
+    // Jellyfish keeps Claude Code's memory files out of the context, and an agent that knows where they live
+    // (~/.claude/projects/<project>/memory) does not read, search or write them with a tool either.
+    if (usesMemoryFiles(JSON.stringify(e)) && (await memoryUse($)) === 'none') {
+      return { deny: "Jellyfish: this thread uses no memory, Claude Code's memory files included. Use Elephant or Inactive brings them back." }
+    }
     return next(e)
   })
 

package/mod/peer-thread-mark/tests/modes.test.tsx

@@ -77,12 +77,24 @@ test('Elephant turns OpenViking on, Inactive keeps Claude Code memory alone, Jel
   await search()
   expect(toolRuns).toBe(1)
   expect((await $.prompt.section({ name: 'memory', text: 'how memory works' })).text).toBeNull()
+  // Nor its memory files, read, searched or changed with a tool; other files under ~/.claude still are.
+  const denied = async (input: object) => {
+    const before = toolRuns
+    const result = (await $.tool.call(input as never)) as { deny?: string }
+    return toolRuns === before && Boolean(result?.deny)
+  }
+  expect(await denied({ tool: 'Read', file_path: '/home/.claude/projects/p/memory/peer-proof.md' })).toBe(true)
+  expect(await denied({ tool: 'Bash', command: 'cd ~/.claude && cat projects/p/memory/MEMORY.md' })).toBe(true)
+  expect(await denied({ tool: 'Grep', pattern: '12/13', path: '/home/.claude/projects' , glob: '**/memory/*.md' })).toBe(true)
+  expect(await denied({ tool: 'Read', file_path: '/home/.claude/settings.json' })).toBe(false)
+  expect(await denied({ tool: 'Read', file_path: '/repo/.claude-plugin/memory.json' })).toBe(false)
   const kept = (await context()).blocks.find(b => b.name === 'claudeMd')?.text ?? ''
   expect(kept).toContain('Be brief.')
   expect(kept).not.toContain('a fact')
 
   // Pressing the lit Jellyfish stops sharing: Inactive, OpenViking still off, Claude Code's own memory back.
   await band.press({ key: 'jellyfish' } as never)
+  expect(await denied({ tool: 'Read', file_path: '/home/.claude/projects/p/memory/peer-proof.md' })).toBe(false)
   expect(env.OPENVIKING_MEMORY_ENABLED).toBe('0')
   expect(await recalled()).toEqual(['kept'])
   expect((await $.prompt.section({ name: 'memory', text: 'how memory works' })).text).toBe('how memory works')
@@ -97,3 +109,74 @@ test('Elephant turns OpenViking on, Inactive keeps Claude Code memory alone, Jel
   expect(cursorMoves()[0]?.slice(-3)).toEqual(['s1', '/t/s1.jsonl', '/repo'])
   await band.unmount()
 })
+
+test('a bare /peer turn carries no memory; the mode picked after it decides the turns that follow', async ($, on) => {
+  let shared = false
+  on('env.get', () => ({ value: '/home' }) as never)
+  on('fs.read', (_, e) => {
+    const path = String((e as { path?: string }).path ?? '')
+    if (path.endsWith('settings.json')) return { value: JSON.stringify({ hooks: { UserPromptSubmit: [{ hooks: [{ command: '"/n/node" "/p/peer.mjs" hook prompt # peer-hook' }] }] } }) } as never
+    if (path.endsWith('/sessions/s1') && shared) return { value: JSON.stringify({ workspace: 'hotovo' }) } as never
+    throw new Error('none')
+  })
+  on('process.run', () => ({ value: { stdout: JSON.stringify({ connected: true, saves: [] }), stderr: '', exitCode: 0 } }) as never)
+  on('env.set', () => ({ value: {} }) as never)
+  on('session.id', () => ({ value: 's1' }) as never)
+  on('session.cwd', () => ({ value: '/repo' }) as never)
+  on('clock.now', () => ({ value: 1 }) as never)
+  on('command.register', (_, e) => ({ value: { command: (e as { name: string }).name } }) as never)
+  on('ui.status', () => ({ value: undefined }) as never)
+  on('ui.invalidate', () => ({ value: undefined }) as never)
+  on('ui.toast', () => ({ value: undefined }) as never)
+  on('session.start', (_, e) => ({ cwd: e.cwd }))
+  // The CLI's hook writes the marker while /peer goes in.
+  on('prompt.submit', (_, e) => {
+    if ((e as { command?: { name: string } }).command?.name === 'peer') shared = true
+    return { text: (e as { text: string }).text } as never
+  })
+  on('turn.complete', (_, e) => ({ text: (e as { answer: string }).answer }) as never)
+  on('prompt.section', () => ({ text: 'how memory works' }) as never)
+  on('prompt.context', (_, e) => ({ blocks: (e as { blocks: unknown[] }).blocks }) as never)
+
+  const memory = async () => {
+    const section = (await $.prompt.section({ name: 'memory', text: 'how memory works' })).text
+    const context = await $.prompt.context({
+      blocks: [{ name: 'claudeMd', text: CLAUDE_MD }],
+      instructionFiles: [{ path: MEMORY_FILE, kind: 'memory', content: '- a fact' }],
+    })
+    const md = context.blocks.find(b => b.name === 'claudeMd')?.text ?? ''
+    expect(md).toContain('Be brief.')
+    return { section, fact: md.includes('a fact') }
+  }
+  const endTurn = () => $.turn.complete({ answer: 'ok', durationMs: 1, isAborted: false, turnId: 't', reason: 'end_turn' } as never)
+
+  await $.session.start({ cwd: '/', surface: 'desktop', isInteractive: true })
+  expect(await memory()).toEqual({ section: 'how memory works', fact: true })
+
+  // /peer alone, the thread's first message: no memory in that turn, though Elephant is the default.
+  await $.prompt.submit({ text: '/peer', command: { name: 'peer', args: '' } } as never)
+  expect(await memory()).toEqual({ section: null, fact: false })
+  await endTurn()
+  expect(await memory()).toEqual({ section: 'how memory works', fact: true })
+
+  // Use Jellyfish after it: nothing again, so the thread never held any.
+  const band = await $.ui.mount({ ...BAND, surface: 'desktop' })
+  await band.press({ key: 'jellyfish' } as never)
+  await $.prompt.submit({ text: 'work' } as never)
+  expect(await memory()).toEqual({ section: null, fact: false })
+  await endTurn()
+  await band.unmount()
+
+  // /peer elephant names the mode itself: its own turn is still bare, the next one has memory.
+  await $.prompt.submit({ text: '/peer elephant', command: { name: 'peer', args: 'elephant' } } as never)
+  expect(await memory()).toEqual({ section: null, fact: false })
+  await endTurn()
+  await $.prompt.submit({ text: 'work' } as never)
+  expect(await memory()).toEqual({ section: 'how memory works', fact: true })
+
+  // /peer with a message is work: the mode decides its memory.
+  await $.prompt.submit({ text: '/peer jellyfish', command: { name: 'peer', args: 'jellyfish' } } as never)
+  await endTurn()
+  await $.prompt.submit({ text: '/peer fix it', command: { name: 'peer', args: 'fix it' } } as never)
+  expect(await memory()).toEqual({ section: null, fact: false })
+})

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@webinson/peer",
-  "version": "0.4.22",
+  "version": "0.4.24",
   "description": "Share chosen Claude Code and Codex threads with your team: who has agents running and on what.",
   "license": "MIT",
   "type": "module",
   "bin": {
     "peer": "bin/peer.mjs",
-    "peer-codex": "mod/codex/client/run.sh"
+    "peer-codex": "bin/peer-codex.mjs"
   },
   "files": [
     "bin",