@webinson/peer 0.4.15 → 0.4.17

package/README.md

@@ -1,7 +1,7 @@
 # Peer
 
 See which people on your team have agents running, on what they work, and which stopped lately.
-Only the Claude Code threads where someone typed `/peer` are shared.
+Only the Claude Code and Codex threads explicitly shared through Peer appear in the list.
 
 ```bash
 npm install -g @webinson/peer
@@ -19,12 +19,12 @@ In a Claude Code thread:
 - `/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.
 - A band above the prompt shows the thread's memories (`17 memories`), `Use Elephant` and `Use Jellyfish`, and
-  `● Active` (shared) or `○ Inactive` at the right; hovering a control explains it. The modes decide what memory
-  the thread uses:
-  - **Use Elephant** (shared): your OpenViking memory, recalled with each prompt and saved as the 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; OpenViking stays off.
-  - **Use Jellyfish** (shared): no memory at all, neither OpenViking nor Claude Code's own (`MEMORY.md`).
+  `● Active` (shared) or `○ Inactive` at the right; a press says in a toast what the thread now uses. The modes
+  decide what memory the thread uses:
+  - **Use Elephant** (shared): PeerMemory (your personal OpenViking), recalled with each prompt and saved as the
+    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.
 
   Pressing the lit mode again stops sharing (Inactive); pressing either while Inactive shares again. Every thread
@@ -79,7 +79,56 @@ a terminal does.
 
 - A resumed or forked session can get a new session id. It is then not shared until `/peer` again.
 - Subagents do not appear: the hooks Peer uses fire for the main thread only.
-- Codex is not supported yet.
+
+## Codex
+
+Install the npm package and set up the Peer terminal with:
+
+```bash
+npm install -g @webinson/peer
+peer login --codex --client you@company.com
+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.
+
+For the plugin alone, omit `--client`. The Codex plugin lives under [`mod/codex`](mod/codex)
+in its own marketplace.
+
+In stock Codex, send `peer: start`, `peer: stop`, `peer: list`, `peer: thread`, or
+`peer: all [words] [here] [--newest | --oldest] [page N]`. The hook answers these locally.
+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/`.
+
+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
+keyboard controls. `/peer [message]` shares the thread and submits an optional message;
+`/peer stop` stops sharing. `/peer-list`, `/peer-thread` and `/peer-all` open terminal panels.
+The threads panel refreshes while open; the memory search accepts the same words and filters
+as Claude Code.
+
+- **Elephant** shares the thread and allows the installed OpenViking plugin and Codex's own
+  memory. OpenViking receives only the turns from this thread's Elephant intervals.
+- **Jellyfish** shares the thread with both memory integrations off. Instructions such as
+  `AGENTS.md` stay available. Codex's own memory can be read again in another mode. Its native
+  generation remains off for that thread so another Codex client sharing the same history
+  cannot extract the Jellyfish turns later.
+- **Inactive** stops sharing. Codex's own memory follows your usual settings; the OpenViking
+  plugin is off in this client.
+
+The mode applies to future turns. Context already present in the chat stays there. Use the
+Peer terminal client to enforce these modes; stock Codex and separately configured memory tools
+follow their own settings. `peer uninstall --codex` removes the plugin from Codex.
 
 ## Team memory (optional)
 

package/bin/codex-thread-mark.mjs

@@ -0,0 +1,232 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+// Codex's lifecycle hooks use their own event and output shapes. Keep Claude's
+// title updates and UI out of this adapter.
+const local = (reason) => ({ decision: "block", reason });
+const MARKETPLACE = "webinson-peer-codex";
+const PLUGIN = `peer-thread-mark@${MARKETPLACE}`;
+const setupFile = (peer) => path.join(peer.home, "codex-cli.json");
+
+export function installCodex(peer, { client = false } = {}) {
+  if (peer.cli.includes(`${path.sep}_npx${path.sep}`)) {
+    throw new Error("Codex needs a lasting `peer`: run `npm install -g @webinson/peer`, then `peer install --codex`.");
+  }
+  const marketplace = fs.realpathSync(path.join(peer.mod, "codex"));
+  let clientPath = peer.readJson(setupFile(peer))?.client;
+  if (client) {
+    if (process.env.PEER_CODEX_CLIENT) {
+      clientPath = path.resolve(process.env.PEER_CODEX_CLIENT);
+      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");
+    }
+  }
+
+  const binary = process.env.PEER_CODEX || (client ? clientPath : "codex");
+  const runCodex = (args, capture = false) => codex(args, { binary, capture });
+  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;
+  if (moving && previous.marketplaceSource?.sourceType !== "local") {
+    throw new Error(`Codex marketplace ${MARKETPLACE} already uses a non-local source`);
+  }
+  if (moving) runCodex(["plugin", "marketplace", "remove", MARKETPLACE]);
+  let added = false;
+  try {
+    runCodex(["plugin", "marketplace", "add", marketplace]);
+    added = true;
+    runCodex(["plugin", "add", PLUGIN]);
+    peer.writeJson(setupFile(peer), { node: process.execPath, peer: peer.cli, client: clientPath });
+  } catch (error) {
+    if (moving) {
+      try {
+        if (added) runCodex(["plugin", "marketplace", "remove", MARKETPLACE]);
+        runCodex(["plugin", "marketplace", "add", previous.marketplaceSource.source]);
+      } catch {
+        console.error(`Could not restore the previous ${MARKETPLACE} marketplace.`);
+      }
+    }
+    throw error;
+  }
+  console.log("Codex: Peer installed. Review and trust its hooks in /hooks.");
+  if (client) console.log("Start the Peer terminal with `peer-codex`.");
+}
+
+export function uninstallCodex(peer) {
+  const clientPath = peer.readJson(setupFile(peer))?.client;
+  const binary = process.env.PEER_CODEX || (clientPath && fs.existsSync(clientPath) ? clientPath : "codex");
+  codex(["plugin", "remove", PLUGIN], { binary });
+  fs.rmSync(setupFile(peer), { force: true });
+  console.log("Codex: Peer's plugin removed.");
+}
+
+function codex(args, { binary, capture = false }) {
+  return execFileSync(binary, args, {
+    stdio: capture ? ["ignore", "pipe", "inherit"] : "inherit",
+    encoding: "utf8",
+    timeout: 60_000,
+  });
+}
+
+const modeOf = (peer, session) => {
+  const mark = peer.readJson(peer.markerOf(session));
+  return mark?.workspace ? mark.mode === "jellyfish" ? "jellyfish" : "elephant" : "inactive";
+};
+
+// The capture hook sees only these windows. Closing one freezes the transcript
+// that OpenViking can recover on a later resume, even if a worker missed a turn.
+function recordMode(peer, session, before, after) {
+  if (before === after) return;
+  const file = path.join(peer.home, "codex-capture", `${session}.json`);
+  const saved = peer.readJson(file);
+  const windows = Array.isArray(saved) ? saved : [];
+  const now = Date.now();
+  const last = windows.at(-1);
+  if (last?.end === null) {
+    last.end = now;
+    if (before === "inactive" && last.mode === "elephant") {
+      // Logout or expiry may have removed a marker without a final hook. Only
+      // keep the old window through its last known opt-in projection.
+      const snapshot = path.join(peer.home, "codex-capture", "rollouts", `${session}.jsonl`);
+      const observed = fs.statSync(snapshot, { throwIfNoEntry: false })?.mtimeMs;
+      last.end = Math.max(last.start, Math.min(now, Math.ceil(observed ?? last.start)));
+    }
+  }
+  if (after !== "inactive") windows.push({ mode: after, start: now, end: null });
+  peer.writeJson(file, windows);
+}
+
+async function setMode(peer, id, cwd, target, { toggle = false, working = false } = {}) {
+  const session = `codex-${id}`;
+  const before = modeOf(peer, session);
+  const mode = toggle && before === target ? "inactive" : target;
+  const saved = peer.signedIn();
+  recordMode(peer, session, before, mode);
+  if (mode === "inactive") return peer.stopSharing(saved, session, cwd, "codex");
+  return (await peer.shareThread(saved, session, cwd, working, "codex", mode)).said;
+}
+
+const countMemories = ({ saves }) => {
+  if (!saves) return null;
+  const items = saves.flatMap((save) => save.items);
+  const updated = new Set(items.filter((item) => item.change === "updated" && !item.systemText).map((item) => `${item.type}:${item.name}`));
+  return items.filter((item) => item.change === "added" || item.systemText).length + updated.size;
+};
+
+export async function codexControl(input, peer) {
+  const { action, session_id: id, cwd, query = "" } = input;
+  const session = `codex-${id}`;
+  if (!peer.validSession(id) || !peer.validSession(session)) throw new Error("invalid Codex session id");
+
+  let output;
+  let memoryCount;
+  let memoryPage;
+  switch (action) {
+    case "status":
+      memoryCount = await peer.threadMemories(id, true).then(countMemories).catch(() => null);
+      break;
+    case "elephant":
+    case "jellyfish":
+      output = await setMode(peer, id, cwd, action, { toggle: true });
+      break;
+    case "start":
+      output = await setMode(peer, id, cwd, modeOf(peer, session) === "jellyfish" ? "jellyfish" : "elephant", { working: input.working === true });
+      break;
+    case "stop":
+      output = await setMode(peer, id, cwd, "inactive");
+      break;
+    case "list":
+      output = await peer.listText(peer.signedIn());
+      break;
+    case "thread": {
+      const memories = await peer.threadMemories(id, true);
+      output = peer.threadMemoryText(memories);
+      memoryCount = countMemories(memories);
+      break;
+    }
+    case "all": {
+      const filters = peer.memoryQuery(query.split(/\s+/).filter(Boolean), cwd || process.cwd());
+      memoryPage = { ...await peer.memoryPage(filters), here: filters.here };
+      break;
+    }
+    default:
+      throw new Error("unknown Codex Peer action");
+  }
+  return { mode: modeOf(peer, session), output, memoryCount, memoryPage };
+}
+
+export async function codexHook(input, peer) {
+  const { hook_event_name: event, session_id: id, cwd } = input;
+  const session = `codex-${id}`;
+  if (input.agent_id || !peer.validSession(id) || !peer.validSession(session)) return;
+
+  switch (event) {
+    case "SessionStart":
+      peer.forgetOldThreads();
+      await peer.teamHook("team-start", { ...input, session_id: session });
+      if (input.source === "resume") await peer.reportQuietly(session, "idle", cwd, "codex");
+      return;
+    case "Stop":
+    case "Interrupt":
+      await peer.reportQuietly(session, "idle", cwd, "codex", 1500);
+      return;
+    case "SessionEnd":
+      await peer.reportQuietly(session, "stopped", cwd, "codex", 1500);
+      return;
+    case "UserPromptSubmit":
+      return promptHook(String(input.prompt ?? "").trim(), id, cwd, peer);
+  }
+}
+
+async function promptHook(prompt, id, cwd, peer) {
+  const session = `codex-${id}`;
+  // The text form also works in clients that handle slash commands before submitting a turn.
+  const all = /^(?:\/peer-all|peer:\s+all)(?:\s+([\s\S]*))?$/.exec(prompt);
+  if (all) {
+    const query = peer.memoryQuery((all[1] ?? "").split(/\s+/).filter(Boolean), cwd || process.cwd());
+    return local(await peer.memoryText(query).catch((error) => `Peer: your memories did not load (${error.message})`));
+  }
+  if (/^(?:\/peer-list|peer:\s+list)$/.test(prompt)) {
+    try {
+      return local(await peer.listText(peer.signedIn()));
+    } catch (error) {
+      return local(`Peer: ${error.message}`);
+    }
+  }
+  if (/^(?:\/peer-thread|peer:\s+thread)$/.test(prompt)) {
+    try {
+      return local(peer.threadMemoryText(await peer.threadMemories(id, true)));
+    } catch (error) {
+      return local(`Peer: your thread memories did not load (${error.message})`);
+    }
+  }
+
+  const share = /^(?:\/peer|peer:\s+start)(?:\s+([\s\S]*))?$/.exec(prompt);
+  const message = share?.[1]?.trim() ?? "";
+  const stop = (share && message === "stop") || /^peer:\s+stop$/.test(prompt);
+  if (share || stop) {
+    try {
+      if (stop) return local(await setMode(peer, id, cwd, "inactive"));
+      const mode = modeOf(peer, session);
+      const said = await setMode(peer, id, cwd, mode === "inactive" ? "elephant" : mode, { working: Boolean(message) });
+      if (!message) return local(said);
+      return {
+        hookSpecificOutput: {
+          hookEventName: "UserPromptSubmit",
+          additionalContext: `${said}\nThe user included a message after their Peer command. Continue with that message.`,
+        },
+      };
+    } catch (error) {
+      return local(`Peer: ${error.message}`);
+    }
+  }
+  await peer.reportQuietly(session, "working", cwd, "codex");
+  if (modeOf(peer, session) === "elephant") {
+    return peer.teamHook("team-prompt", { session_id: session, cwd, prompt });
+  }
+}

package/bin/peer.mjs

@@ -30,8 +30,8 @@ const MARKETPLACE = "webinson-peer";
 
 const HELP = `peer: share chosen agent threads with your team
 
-  peer login [email] [--hub <url>] [--workspace <slug>]
-                    sign in once and set up Claude Code (/peer, /peer stop, /peer-list)
+  peer login [email] [--hub <url>] [--workspace <slug>] [--codex [--client]]
+                    sign in once and set up Claude Code or Codex
   peer list         people in the workspace, their shared threads and what they work on
   peer status       who you are, the workspace and the threads this computer shares
   peer doctor       why Peer's hook did not answer /peer
@@ -43,8 +43,9 @@ const HELP = `peer: share chosen agent threads with your team
   peer all [words] [here] [--newest | --oldest] [page N]
                     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      set up Claude Code again (hooks, the two commands and the thread mark)
-  peer uninstall    remove them from Claude Code
+  peer install [--codex [--client]]
+                    set up the thread mark; --client also builds 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
@@ -133,8 +134,8 @@ function workingOn(cwd) {
   return { repository, branch: branch && branch !== "HEAD" ? branch : undefined, repoKey };
 }
 
-async function report(saved, session, state, cwd) {
-  await call(saved, "PUT", `/workspaces/${saved.workspace}/agents/${session}`, { agent: "claude-code", state, ...workingOn(cwd) }, HUB_TIMEOUT_MS);
+async function report(saved, session, state, cwd, agent = "claude-code", timeoutMs = HUB_TIMEOUT_MS) {
+  await call(saved, "PUT", `/workspaces/${saved.workspace}/agents/${session}`, { agent, state, ...workingOn(cwd) }, timeoutMs);
 }
 
 // ---- the list ----
@@ -235,6 +236,28 @@ function log(line) {
   } catch {}
 }
 
+async function shareThread(saved, session, cwd, working, agent, mode) {
+  writeJson(markerOf(session), { workspace: saved.workspace, sharedAt: new Date().toISOString(), mode });
+  const where = workingOn(cwd);
+  const what = [where.repository, where.branch].filter(Boolean).map(plain).join(" @ ");
+  let said = `Peer: this thread is shared in ${saved.workspace}${what ? ` as ${what}` : ""}. Teammates see its repository, branch and state, nothing of the conversation. /peer stop ends it.`;
+  try {
+    await report(saved, session, working ? "working" : "idle", cwd, agent);
+  } catch (error) {
+    said = `Peer: shared, but the hub did not answer yet (${error.message}). The next turn tries again.`;
+  }
+  return { said, what };
+}
+
+async function stopSharing(saved, session, cwd, agent) {
+  const marker = markerOf(session);
+  const shared = readJson(marker);
+  fs.rmSync(marker, { force: true });
+  if (!shared?.workspace) return "Peer: this thread was not shared.";
+  await report({ ...saved, workspace: shared.workspace }, session, "stopped", cwd, agent).catch(() => {});
+  return "Peer: this thread is no longer shared.";
+}
+
 async function hook(event) {
   const input = await readStdin();
   const session = input.session_id;
@@ -268,19 +291,10 @@ async function hook(event) {
         return block(`Peer: ${error.message}`);
       }
       if (argument === "stop") {
-        fs.rmSync(marker, { force: true });
-        if (!shared) return block("Peer: this thread was not shared.", retitle(input, false));
-        await report(saved, session, "stopped", input.cwd).catch(() => {});
-        return block("Peer: this thread is no longer shared.", retitle(input, false));
+        return block(await stopSharing(saved, session, input.cwd), retitle(input, false));
       }
       // `/peer <message>` shares the thread and lets the message through: the command hands it to the model.
-      writeJson(marker, { workspace: saved.workspace, sharedAt: new Date().toISOString() });
-      const where = workingOn(input.cwd);
-      const what = [where.repository, where.branch].filter(Boolean).join(" @ ");
-      const sharedText = `Peer: this thread is shared in ${saved.workspace}${what ? ` as ${what}` : ""}. Teammates see its repository, branch and state, nothing of the conversation. /peer stop ends it.`;
-      let hubError;
-      await report(saved, session, argument ? "working" : "idle", input.cwd).catch((error) => (hubError = error));
-      const said = hubError ? `Peer: shared, but the hub did not answer yet (${hubError.message}). The next turn tries again.` : sharedText;
+      const { said, what } = await shareThread(saved, session, input.cwd, Boolean(argument));
       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.
@@ -319,11 +333,11 @@ function forgetOldThreads() {
 }
 
 // A turn never waits on or fails because of the hub: a report that does not go through is dropped.
-async function reportQuietly(session, state, cwd) {
+async function reportQuietly(session, state, cwd, agent, timeoutMs) {
   const saved = config();
   const marker = readJson(markerOf(session));
   if (!saved?.session || !marker?.workspace) return;
-  await report({ ...saved, workspace: marker.workspace }, session, state, cwd).catch(() => {});
+  await report({ ...saved, workspace: marker.workspace }, session, state, cwd, agent, timeoutMs).catch(() => {});
 }
 
 // ---- Claude Code setup ----
@@ -458,6 +472,10 @@ function option(args, name) {
 }
 
 async function login(args) {
+  const forCodex = args.includes("--codex");
+  const client = args.includes("--client");
+  if (client && !forCodex) throw new Error("--client requires --codex");
+  args = args.filter((arg) => arg !== "--codex" && arg !== "--client");
   const hub = (option(args, "--hub") ?? process.env.PEER_HUB ?? config()?.hub ?? DEFAULT_HUB).replace(/\/+$/, "");
   let workspace = option(args, "--workspace");
   const ask = readline.createInterface({ input: process.stdin, output: process.stderr });
@@ -493,7 +511,8 @@ async function login(args) {
   } finally {
     ask.close();
   }
-  install();
+  if (forCodex) (await import("./codex-thread-mark.mjs")).installCodex(codexPeer, { client });
+  else install();
 }
 
 async function logout() {
@@ -823,19 +842,20 @@ function threadUses(session, prompts) {
   return uses.slice(-200);
 }
 
-async function threadMemories(session) {
+async function threadMemories(session, codex = false) {
   const ov = readJson(OV_CONF);
   if (!ov?.url) return { connected: false, reason: `no OpenViking client config at ${OV_CONF}` };
-  const base = `viking://user/${ov.user}/sessions/cc-${session}`;
+  const base = `viking://user/${ov.user}/sessions/${codex ? "cx" : "cc"}-${session}`;
+  const uses = (prompts) => codex ? [] : threadUses(session, prompts);
   let archives;
   try {
     archives = await ovRead(ov, `/fs/ls?uri=${encodeURIComponent(`${base}/history`)}`);
   } catch (error) {
-    if (/not found|no such|404/i.test(error.message)) return { connected: true, saves: [], uses: threadUses(session, transcriptPrompts(session)) };
+    if (/not found|no such|404/i.test(error.message)) return { connected: true, saves: [], uses: uses(codex ? [] : transcriptPrompts(session)) };
     throw error;
   }
   const saves = [];
-  const prompts = transcriptPrompts(session);
+  const prompts = codex ? [] : transcriptPrompts(session);
   for (const archive of archives.filter((entry) => entry.isDir)) {
     let diff;
     try {
@@ -872,7 +892,15 @@ async function threadMemories(session) {
     items.forEach((item, index) => (item.body = String(bodies[index] ?? "").slice(0, 3000)));
     saves.push({ at: diff.extracted_at ?? archive.modTime, items });
   }
-  return { connected: true, saves: saves.sort((a, b) => String(b.at).localeCompare(String(a.at))), uses: threadUses(session, prompts) };
+  return { connected: true, saves: saves.sort((a, b) => String(b.at).localeCompare(String(a.at))), uses: uses(prompts) };
+}
+
+function threadMemoryText(memories) {
+  if (!memories.connected) return `Peer: ${memories.reason}`;
+  if (!memories.saves.length) return "This thread has not saved anything to memory yet.";
+  return memories.saves.flatMap((save) => [save.at, ...save.items.map((item) =>
+    `  ${item.change} ${item.type} "${item.name}": ${item.lines.join(" / ")}${item.systemText ? "  [holds Claude Code's own text]" : ""}`,
+  )]).join("\n");
 }
 
 // ---- team memory: teammates' published project knowledge at the start of a thread ----
@@ -973,8 +1001,7 @@ function changesSince(cwd, paths, date) {
   return log ? log.split("\n").filter(Boolean).length : 0;
 }
 
-async function teamHook(event) {
-  const input = await readStdin();
+async function teamHook(event, input) {
   const team = readJson(TEAM_FILE);
   const session = input.session_id;
   if (!team || !validSession(session)) return;
@@ -1033,7 +1060,7 @@ async function teamHook(event) {
     ...entries,
     "</teammates-project-knowledge>",
   ].join("\n");
-  answer({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: block } });
+  return { hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: block } };
 }
 
 // ---- your own memory: what your personal OpenViking remembered, listed and searched ----
@@ -1191,6 +1218,13 @@ async function memoryText(query) {
 
 // ---- main ----
 
+const codexPeer = {
+  home: HOME, cli: SELF, mod: MOD_DIR,
+  validSession, readJson, writeJson, markerOf, config, forgetOldThreads,
+  reportQuietly, signedIn, shareThread, stopSharing, listText, memoryQuery, memoryPage, memoryText,
+  threadMemories, threadMemoryText, teamHook,
+};
+
 const [command, ...args] = process.argv.slice(2);
 try {
   switch (command) {
@@ -1211,16 +1245,10 @@ try {
     case "thread": {
       // `peer thread --json <session id>` is for the thread-mark mod's pane.
       const session = args.find((arg) => !arg.startsWith("--"));
-      if (!validSession(session)) throw new Error("usage: peer thread [--json] <claude code session id>");
-      const memories = await threadMemories(session);
+      if (!validSession(session)) throw new Error("usage: peer thread [--json] [--codex] <session id>");
+      const memories = await threadMemories(session, args.includes("--codex"));
       if (args.includes("--json")) console.log(JSON.stringify(memories));
-      else if (!memories.connected) console.log(`Peer: ${memories.reason}`);
-      else if (!memories.saves.length) console.log("This thread has not saved anything to memory yet.");
-      else
-        for (const save of memories.saves) {
-          console.log(save.at);
-          for (const item of save.items) console.log(`  ${item.change} ${item.type} "${item.name}": ${item.lines.join(" / ")}${item.systemText ? "  [holds Claude Code's own text]" : ""}`);
-        }
+      else console.log(threadMemoryText(memories));
       break;
     }
     case "status":
@@ -1231,14 +1259,31 @@ try {
       break;
     case "install":
       signedIn();
-      install();
+      if (args.includes("--codex")) {
+        (await import("./codex-thread-mark.mjs")).installCodex(codexPeer, { client: args.includes("--client") });
+      } else if (args.includes("--client")) throw new Error("--client requires --codex");
+      else install();
       break;
     case "uninstall":
-      uninstall();
+      if (args.includes("--codex")) (await import("./codex-thread-mark.mjs")).uninstallCodex(codexPeer);
+      else uninstall();
+      break;
+    case "codex-control":
+      answer(await (await import("./codex-thread-mark.mjs")).codexControl(await readStdin(), codexPeer));
       break;
     case "hook":
       // A hook never breaks the person's session: whatever goes wrong, it exits 0.
-      await (args[0]?.startsWith("team-") ? teamHook(args[0]) : hook(args[0])).catch((error) => log(`hook ${args[0]} failed: ${error?.message ?? error}`));
+      await (async () => {
+        if (args[0] === "codex") {
+          const { codexHook } = await import("./codex-thread-mark.mjs");
+          const output = await codexHook(await readStdin(), codexPeer);
+          if (output) answer(output);
+        } else if (args[0]?.startsWith("team-")) {
+          const output = await teamHook(args[0], await readStdin());
+          if (output) answer(output);
+        }
+        else await hook(args[0]);
+      })().catch((error) => log(`hook ${args[0]} failed: ${error?.message ?? error}`));
       break;
     case "all": {
       // `peer all --json …` is for the thread-mark mod's pane; without a personal OpenViking it says so.

package/mod/codex/.agents/plugins/marketplace.json

@@ -0,0 +1,12 @@
+{
+  "name": "webinson-peer-codex",
+  "interface": { "displayName": "Peer" },
+  "plugins": [
+    {
+      "name": "peer-thread-mark",
+      "source": { "source": "local", "path": "./peer-thread-mark" },
+      "policy": { "installation": "AVAILABLE", "authentication": "ON_INSTALL" },
+      "category": "Productivity"
+    }
+  ]
+}

package/mod/codex/client/.gitattributes

@@ -0,0 +1 @@
+*.patch whitespace=-blank-at-eol