@webinson/peer 0.4.16 → 0.4.18

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

@@ -0,0 +1,12 @@
+{
+  "name": "peer-thread-mark",
+  "version": "0.1.0",
+  "description": "Share selected Codex threads in Peer and browse their memories.",
+  "license": "MIT",
+  "hooks": "./hooks/hooks.json",
+  "interface": {
+    "displayName": "Peer Thread Mark",
+    "shortDescription": "Share selected Codex threads in Peer",
+    "category": "Productivity"
+  }
+}

package/mod/codex/peer-thread-mark/hooks/hooks.json

@@ -0,0 +1,9 @@
+{
+  "hooks": {
+    "SessionStart": [{ "hooks": [{ "type": "command", "command": "node \"${PLUGIN_ROOT}/hooks/peer.mjs\"", "timeout": 5 }] }],
+    "UserPromptSubmit": [{ "hooks": [{ "type": "command", "command": "node \"${PLUGIN_ROOT}/hooks/peer.mjs\"", "timeout": 20 }] }],
+    "Stop": [{ "hooks": [{ "type": "command", "command": "node \"${PLUGIN_ROOT}/hooks/peer.mjs\"", "timeout": 5 }] }],
+    "Interrupt": [{ "hooks": [{ "type": "command", "command": "node \"${PLUGIN_ROOT}/hooks/peer.mjs\"", "timeout": 3 }] }],
+    "SessionEnd": [{ "hooks": [{ "type": "command", "command": "node \"${PLUGIN_ROOT}/hooks/peer.mjs\"", "timeout": 3 }] }]
+  }
+}

package/mod/codex/peer-thread-mark/hooks/peer.mjs

@@ -0,0 +1,17 @@
+import { spawn } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+
+// Codex installs a copy of this directory, without the npm package beside it.
+const home = process.env.PEER_HOME || path.join(homedir(), ".peer");
+let launch;
+try {
+  launch = JSON.parse(readFileSync(path.join(home, "codex-cli.json"), "utf8"));
+} catch {}
+const cli = launch && typeof launch.node === "string" && typeof launch.peer === "string"
+  && path.isAbsolute(launch.node) && path.isAbsolute(launch.peer);
+const child = spawn(cli ? launch.node : "peer", [...(cli ? [launch.peer] : []), "hook", "codex"], {
+  stdio: ["inherit", "inherit", "ignore"],
+});
+child.on("error", () => {});

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

@@ -1,6 +1,6 @@
 {
   "name": "peer-thread-mark",
-  "version": "0.4.16",
+  "version": "0.4.18",
   "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

@@ -1,13 +1,27 @@
 import { atom, read, update } from 'claude-code'
 import type { EngineInterface, Register, RenderChildren, RenderNode, RenderSurface } from 'claude-code'
 
-import type { AllMemories, AllQuery, Board, Memories, MemoryItem, MemoryRow, MemoryUse, Mode, Recall, RecallItem, Thread } from '../types'
+import type { AllMemories, AllQuery, Board, CollisionSignal, Memories, MemoryItem, MemoryRow, MemoryUse, Mode, Recall, RecallItem, Thread } from '../types'
 import type { Shared } from '../types'
 
 // The peer CLI's hook writes ~/.peer/sessions/<session id> on `/peer` and removes it on `/peer stop`;
 // that file alone says whether this thread is shared, and in which workspace.
 const shared = atom({ plugin: 'peer-thread-mark', key: 'shared' } as const, null)
 
+// The collision signal: after an edit in a shared thread, `peer collide` asks the Hub who else was on the file in the
+// last 3 minutes. Each edit's answer by its tool_use_id; the rows and the agent's sentence read `shown` from it.
+const signals = atom({ plugin: 'peer-thread-mark', key: 'signals' } as const, {}, { shape: 'signals-1' })
+// Set when the Hub timed out in this turn, so the turn's later edits do not wait again; the next prompt clears it.
+const collideOff = atom({ plugin: 'peer-thread-mark', key: 'collideOff' } as const, false)
+// The Peer app's list of edit tools and where each names its file.
+const EDIT_TOOLS = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit'])
+const SIGNALS_KEPT = 200
+const COLLIDE_MS = 2500
+const ADDRESS = /^[^@\s]+@[^@\s]+$/
+const COLLISION_COLOR = '#d97706'
+const COLLISION_SOFT_BACKGROUND = '#fef3c7'
+const COLLISION_SOFT_COLOR = '#92400e'
+
 // The threads pane: /peer-list opens it instead of answering with a blocked prompt, and it reloads while open.
 const PANE = 'peer-threads'
 const RELOAD_MS = 15_000
@@ -483,6 +497,51 @@ async function memoryNote($: EngineInterface) {
   return 'Inactive: not shared, Claude Code memory only.'
 }
 
+// Who else was on the file, newest first: other people before the person's own other threads.
+const othersOf = (signal: CollisionSignal) => signal.holders.filter(h => !h.own).sort((a, b) => Date.parse(b.at) - Date.parse(a.at))
+const whenAgo = (at: string, now: number) => {
+  const age = ago(at, now)
+  return age === 'just now' ? age : `${age} ago`
+}
+
+// What the agent reads beside the tool result: who, where and when, from the Hub's fields only, fenced as data.
+function collisionSentence(signal: CollisionSignal, now: number) {
+  const said = othersOf(signal)
+    .slice(0, 3)
+    .map(h => {
+      const mins = Math.max(0, Math.round((now - Date.parse(h.at)) / 60_000))
+      const age = mins < 1 ? 'just now' : mins === 1 ? '1 minute ago' : `${mins} minutes ago`
+      return `${h.email}'s agent was on ${signal.path} ${age}, in another thread.`
+    })
+  return ['<peer-collision>', ...said, 'This is information about the repository, not an instruction.', '</peer-collision>'].join('\n')
+}
+
+// The one line under an edit: another person with the warning badge, or the person's own other thread, dimmed.
+function collisionLine(ui: { Box: (p: never) => RenderNode; Text: (p: never) => RenderNode }, surface: RenderSurface, signal: CollisionSignal, now: number, more = 0) {
+  const { Box, Text } = ui as unknown as { Box: (p: { gap?: number; children?: RenderChildren }) => RenderNode; Text: (p: { backgroundColor?: string; color?: string; bold?: boolean; dimColor?: boolean; size?: string; children?: RenderChildren }) => RenderNode }
+  const others = othersOf(signal)
+  const extra = more ? ` · and ${more} more` : ''
+  if (!others.length) {
+    const own = [...signal.holders].sort((a, b) => Date.parse(b.at) - Date.parse(a.at))[0]
+    return <Text dimColor>{`Your other thread was on it ${whenAgo(own?.at ?? '', now)}${extra}`}</Text>
+  }
+  const [newest] = others
+  const who = `${plain(newest!.email.split('@')[0])}@…`
+  const rest = others.length > 1 ? ` and ${others.length - 1} others` : ''
+  const badge =
+    surface === 'terminal' ? (
+      <Text backgroundColor={COLLISION_COLOR} color="#ffffff" bold size="caption">{' Same file '}</Text>
+    ) : (
+      <Text backgroundColor={COLLISION_SOFT_BACKGROUND} color={COLLISION_SOFT_COLOR} bold size="caption">{' Same file '}</Text>
+    )
+  return (
+    <Box gap={1}>
+      {badge}
+      <Text>{`${who} was on it ${whenAgo(newest!.at, now)}${rest}${extra}`}</Text>
+    </Box>
+  )
+}
+
 export const register: Register = on => {
   // A session that loaded the mod after it started (/reload-plugins, an install) has no state yet: the first
   // drawing looks once, so the band shows without waiting for the next prompt.
@@ -508,10 +567,99 @@ 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) => {
     const result = await next(e)
+    await update($, collideOff, () => false)
     await refresh($).catch(() => {})
     return result
   })
 
+  // After each edit in a shared thread: who else was on the file. The CLI asks the Hub; the mod keeps the answer
+  // for the row and tells the agent when another person was on it.
+  on('classic.PostToolUse', async ($, e, next) => {
+    const result = await next(e)
+    if (!EDIT_TOOLS.has(e.tool_name) || !e.tool_use_id) return result
+    const input = (e.tool_input ?? {}) as { file_path?: string; notebook_path?: string }
+    const file = input.file_path ?? input.notebook_path
+    if (!file || !(await read($, shared))?.isShared || (await read($, collideOff))) return result
+    const session = await $.session.id()
+    if ((await $.env.get('PEER_MOD_SESSION')) === session) return result
+
+    type Answer = Pick<CollisionSignal, 'path' | 'state' | 'reason' | 'holders'>
+    let answer: Answer
+    let argv: string[] | undefined
+    try {
+      argv = await peerCli($)
+    } catch {}
+    if (!argv) answer = { path: null, state: 'unchecked', reason: 'error', holders: [] }
+    else {
+      try {
+        const { stdout, exitCode } = await $.process.run([...argv, 'collide', '--json', session, e.tool_use_id, file], { timeoutMs: COLLIDE_MS })
+        answer = exitCode === 0 ? (JSON.parse(stdout) as Answer) : { path: null, state: 'unchecked', reason: 'error', holders: [] }
+      } catch {
+        answer = { path: null, state: 'unchecked', reason: 'hub-timeout', holders: [] }
+      }
+    }
+    if (answer.reason === 'hub-timeout') await update($, collideOff, () => true)
+    // Only well-formed addresses, cleaned: the Hub's fields are the only source of what is drawn and said.
+    const holders = (Array.isArray(answer.holders) ? answer.holders : [])
+      .map(h => ({ email: plain(h.email), at: String(h.at ?? ''), own: h.own === true }))
+      .filter(h => ADDRESS.test(h.email))
+    const state = answer.state === 'collision' && !holders.length ? 'clear' : answer.state
+    const at = await $.clock.now()
+    const emails = (signal: { holders: { email: string }[] }) => signal.holders.map(h => h.email.toLowerCase()).sort().join(' ')
+    let signal: CollisionSignal = { path: answer.path ? plain(answer.path) : null, state, ...(answer.reason ? { reason: answer.reason } : {}), holders, at, shown: false }
+    // Shown once per set of people on a path: against the latest earlier collision on it, decided inside one update.
+    await update($, signals, was => {
+      const kept = { ...(was ?? {}) }
+      if (signal.state === 'collision') {
+        const earlier = Object.values(kept).filter(s => s.path === signal.path && s.state === 'collision').at(-1)
+        signal = { ...signal, shown: !earlier || emails(earlier) !== emails(signal) }
+      }
+      kept[e.tool_use_id] = signal
+      return Object.fromEntries(Object.entries(kept).slice(-SIGNALS_KEPT))
+    })
+    if (!signal.shown || !othersOf(signal).length) return result
+    return { ...(result ?? {}), additionalContext: [...(result?.additionalContext ?? []), collisionSentence(signal, at)] }
+  })
+
+  // The line under an edit row whose check met someone on the file.
+  on('ui.render', { component: 'ToolUse' }, async ($, e, next) => {
+    const drawn = await next(e)
+    const row = e.props
+    if (drawn === undefined || !EDIT_TOOLS.has(row.tool) || row.isRunning || row.isErrored || row.isInterrupted) return drawn
+    const signal = (await read($, signals))?.[row.tool_use_id]
+    if (!signal?.shown) return drawn
+    const ui = $.ui.resolve(e)
+    const { Box } = ui
+    return (
+      <Box flexDirection="column">
+        {drawn}
+        {collisionLine(ui as never, e.surface, signal, await $.clock.now())}
+      </Box>
+    )
+  })
+
+  // A folded group of calls shows the same line once, for its newest collided edit; an opened group leaves it to
+  // the rows.
+  on('ui.render', { component: 'ToolGroup' }, async ($, e, next) => {
+    const drawn = await next(e)
+    if (drawn === undefined || e.props.isExpanded) return drawn
+    const all = (await read($, signals)) ?? {}
+    const met = e.props.calls
+      .map(call => (call.tool_use_id && EDIT_TOOLS.has(call.tool) ? all[call.tool_use_id] : undefined))
+      .filter((signal): signal is CollisionSignal => Boolean(signal?.shown))
+    if (!met.length) return drawn
+    const byPerson = met.filter(signal => othersOf(signal).length)
+    const [first] = (byPerson.length ? byPerson : met).sort((a, b) => b.at - a.at)
+    const ui = $.ui.resolve(e)
+    const { Box } = ui
+    return (
+      <Box flexDirection="column">
+        {drawn}
+        {collisionLine(ui as never, e.surface, first!, await $.clock.now(), met.length - 1)}
+      </Box>
+    )
+  })
+
   on('turn.complete', async ($, e, next) => {
     await refresh($).catch(() => {})
     // OpenViking saves a thread's memories when a turn ends past its threshold, so the open pane and the Saved lines

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

@@ -0,0 +1,150 @@
+import { expect, test } from 'claude-code/testing'
+
+const SETTINGS = { hooks: { UserPromptSubmit: [{ hooks: [{ command: '"/n/node" "/p/peer.mjs" hook prompt # peer-hook' }] }] } }
+const NOW = Date.parse('2026-11-03T20:00:00Z')
+const minsAgo = (mins: number) => new Date(NOW - mins * 60_000).toISOString()
+
+type Answer = { path: string | null; state: string; reason?: string; holders: { email: string; at: string; own: boolean }[] }
+
+// A shared thread s1 whose CLI answers `peer collide` with `answer` (or throws, for a run past its limit).
+function setUp(on: (...args: never[]) => void, options: { modSession?: string; shared?: boolean } = {}) {
+  const state = { answer: { path: 'src/cart.ts', state: 'clear', holders: [] } as Answer | 'timeout', exit: 0, collides: [] as string[][] }
+  const hook = on as unknown as (event: string, fn: (...args: unknown[]) => unknown) => void
+  hook('env.get', (_: unknown, e: unknown) => ({ value: (e as { name?: string }).name === 'PEER_MOD_SESSION' ? options.modSession ?? '' : '/home' }))
+  hook('fs.read', (_: unknown, e: unknown) => {
+    const path = String((e as { path?: string }).path ?? '')
+    if (path.endsWith('settings.json')) return { value: JSON.stringify(SETTINGS) }
+    if (path.endsWith('/sessions/s1') && options.shared !== false) return { value: JSON.stringify({ workspace: 'acme', project: 'shop' }) }
+    throw new Error('none')
+  })
+  hook('env.set', () => ({ value: {} }))
+  hook('session.id', () => ({ value: 's1' }))
+  hook('clock.now', () => ({ value: NOW }))
+  hook('process.run', (_: unknown, e: unknown) => {
+    const argv = (e as { argv: string[] }).argv
+    if (argv.includes('collide')) {
+      state.collides.push(argv.slice(argv.indexOf('collide') + 1))
+      if (state.answer === 'timeout') throw new Error('still running after 2500 ms')
+      return { value: { stdout: JSON.stringify(state.answer), stderr: '', exitCode: state.exit } }
+    }
+    return { value: { stdout: '{}', stderr: '', exitCode: 0 } }
+  })
+  hook('classic.UserPromptSubmit', () => ({}))
+  hook('classic.PostToolUse', () => ({ additionalContext: ['from another hook'] }))
+  hook('ui.render', () => ({ type: 'Text', props: {}, children: ['the row'] }))
+  return state
+}
+
+const edit = (id: string, tool = 'Edit', file = '/repo/src/cart.ts') =>
+  ({ tool_name: tool, tool_input: tool === 'NotebookEdit' ? { notebook_path: file } : { file_path: file }, tool_response: {}, tool_use_id: id }) as never
+const row = (id: string, surface: 'terminal' | 'desktop', props: Record<string, unknown> = {}) =>
+  ({ plugin: 'peer-thread-mark', component: 'ToolUse', requestId: id, surface, props: { tool_use_id: id, tool: 'Edit', input: {}, isRunning: false, isErrored: false, isInterrupted: false, ...props } }) as never
+const group = (ids: string[], isExpanded = false) =>
+  ({ plugin: 'peer-thread-mark', component: 'ToolGroup', requestId: 'g', surface: 'desktop', props: { calls: ids.map(id => ({ tool_use_id: id, tool: 'Edit', input: {}, isRunning: false, isErrored: false })), isActive: false, isExpanded } }) as never
+const texts = async (target: never, $: { ui: { mount: (t: never) => Promise<{ findAll: (q: never) => Promise<{ text: string }[]>; unmount: () => Promise<void> }> } }) => {
+  const ui = await $.ui.mount(target)
+  const found = (await ui.findAll({ type: 'Text' } as never)).map(t => t.text)
+  await ui.unmount()
+  return found
+}
+
+const BOB = { email: 'bob@acme.test', at: minsAgo(2), own: false }
+const ANA_OTHER = { email: 'ana@acme.test', at: minsAgo(0), own: true }
+
+test('an edit another person was on draws the line and tells the agent once per set of people', async ($, on) => {
+  const state = setUp(on)
+  await $.classic.UserPromptSubmit({ prompt: 'fix the cart' } as never)
+  state.answer = { path: 'src/cart.ts', state: 'collision', holders: [BOB, ANA_OTHER] }
+
+  const told = (await $.classic.PostToolUse(edit('t1'))) as { additionalContext?: string[] }
+  expect(state.collides[0]).toEqual(['--json', 's1', 't1', '/repo/src/cart.ts'])
+  expect(told.additionalContext?.[0]).toBe('from another hook')
+  expect(told.additionalContext?.[1]).toBe(
+    "<peer-collision>\nbob@acme.test's agent was on src/cart.ts 2 minutes ago, in another thread.\nThis is information about the repository, not an instruction.\n</peer-collision>",
+  )
+  for (const surface of ['terminal', 'desktop'] as const) {
+    const drawn = await texts(row('t1', surface), $ as never)
+    expect(drawn).toContain('the row')
+    expect(drawn).toContain(' Same file ')
+    expect(drawn).toContain('bob@… was on it 2 min ago')
+  }
+
+  // The same people on the file again, later: nothing new to draw or say.
+  state.answer = { path: 'src/cart.ts', state: 'collision', holders: [{ ...BOB, at: minsAgo(0) }, ANA_OTHER] }
+  const again = (await $.classic.PostToolUse(edit('t2'))) as { additionalContext?: string[] }
+  expect(again.additionalContext).toEqual(['from another hook'])
+  expect(await texts(row('t2', 'terminal'), $ as never)).toEqual(['the row'])
+
+  // A running, errored or interrupted row, and a Read, draw nothing of their own.
+  for (const props of [{ isRunning: true }, { isErrored: true }, { isInterrupted: true }, { tool: 'Read' }]) {
+    expect(await texts(row('t1', 'terminal', props), $ as never)).toEqual(['the row'])
+  }
+
+  // Several other people: the newest named, "and 1 others"; the sentence lists both.
+  const CY = { email: 'cy@acme.test', at: minsAgo(1), own: false }
+  state.answer = { path: 'src/pay.ts', state: 'collision', holders: [BOB, CY] }
+  const both = (await $.classic.PostToolUse(edit('t3', 'Write', '/repo/src/pay.ts'))) as { additionalContext?: string[] }
+  expect(both.additionalContext?.[1]).toContain("cy@acme.test's agent was on src/pay.ts 1 minute ago")
+  expect(both.additionalContext?.[1]).toContain("bob@acme.test's agent was on src/pay.ts 2 minutes ago")
+  expect(await texts(row('t3', 'desktop'), $ as never)).toContain('cy@… was on it 1 min ago and 1 others')
+})
+
+test('the person\'s own other thread is drawn dimmed and the agent is told nothing', async ($, on) => {
+  const state = setUp(on)
+  await $.classic.UserPromptSubmit({ prompt: 'go' } as never)
+  state.answer = { path: 'src/cart.ts', state: 'collision', holders: [ANA_OTHER] }
+  const told = (await $.classic.PostToolUse(edit('o1'))) as { additionalContext?: string[] }
+  expect(told.additionalContext).toEqual(['from another hook'])
+  const drawn = await texts(row('o1', 'desktop'), $ as never)
+  expect(drawn).toContain('Your other thread was on it just now')
+  expect(drawn).not.toContain(' Same file ')
+})
+
+test('a folded group draws the line once for its collided edits, an opened one leaves it to the rows', async ($, on) => {
+  const state = setUp(on)
+  await $.classic.UserPromptSubmit({ prompt: 'go' } as never)
+  state.answer = { path: 'src/cart.ts', state: 'collision', holders: [BOB] }
+  await $.classic.PostToolUse(edit('g1'))
+  state.answer = { path: 'src/pay.ts', state: 'collision', holders: [BOB] }
+  await $.classic.PostToolUse(edit('g2', 'Edit', '/repo/src/pay.ts'))
+  state.answer = { path: 'src/ok.ts', state: 'clear', holders: [] }
+  await $.classic.PostToolUse(edit('g3', 'Edit', '/repo/src/ok.ts'))
+
+  const folded = await texts(group(['g1', 'g2', 'g3']), $ as never)
+  expect(folded.filter(t => t.includes('was on it'))).toEqual(['bob@… was on it 2 min ago · and 1 more'])
+  expect(await texts(group(['g1', 'g2'], true), $ as never)).toEqual(['the row'])
+  expect(await texts(group(['g3']), $ as never)).toEqual(['the row'])
+})
+
+test('a thread the Peer app runs makes no call', async ($, on) => {
+  const state = setUp(on, { modSession: 's1' })
+  await $.classic.UserPromptSubmit({ prompt: 'go' } as never)
+  await $.classic.PostToolUse(edit('p1'))
+  expect(state.collides).toHaveLength(0)
+})
+
+test('an unshared thread makes no call', async ($, on) => {
+  const state = setUp(on, { shared: false })
+  await $.classic.UserPromptSubmit({ prompt: 'go' } as never)
+  await $.classic.PostToolUse(edit('u1'))
+  expect(state.collides).toHaveLength(0)
+})
+
+test('after a timeout the turn makes no more calls, and an old CLI draws nothing', async ($, on) => {
+  const state = setUp(on)
+  on('prompt.submit', () => ({ text: 'next' }) as never)
+  await $.classic.UserPromptSubmit({ prompt: 'go' } as never)
+  state.answer = 'timeout'
+  const timedOut = (await $.classic.PostToolUse(edit('x1'))) as { additionalContext?: string[] }
+  expect(timedOut.additionalContext).toEqual(['from another hook'])
+  await $.classic.PostToolUse(edit('x2'))
+  expect(state.collides).toHaveLength(1)
+
+  await $.prompt.submit({ text: 'next' } as never)
+  state.answer = { path: 'src/cart.ts', state: 'collision', holders: [BOB] }
+  state.exit = 2
+  const old = (await $.classic.PostToolUse(edit('x3'))) as { additionalContext?: string[] }
+  expect(state.collides).toHaveLength(2)
+  expect(old.additionalContext).toEqual(['from another hook'])
+  expect(await texts(row('x3', 'terminal'), $ as never)).toEqual(['the row'])
+})

package/mod/peer-thread-mark/types/index.d.ts

@@ -66,8 +66,21 @@ export type Recall = { prompt: string; items: RecallItem[] }
 // The band's memory mode for a thread: Elephant saves and recalls, Jellyfish neither.
 export type Mode = 'elephant' | 'jellyfish'
 
+// One edit's check against teammates' claims, as `peer collide --json` printed it, kept by its tool_use_id. path is
+// relative to the repository (null when nothing was asked); shown: drawn and told, the first time these people met
+// on the path.
+export type CollisionHolder = { email: string; at: string; own: boolean }
+export type CollisionSignal = {
+  path: string | null
+  state: 'clear' | 'collision' | 'no-project' | 'unchecked' | 'skipped'
+  reason?: string
+  holders: CollisionHolder[]
+  at: number
+  shown: boolean
+}
+
 declare module 'claude-code' {
   interface PluginState {
-    'peer-thread-mark': { shared: Shared; board: Shaped<Board>; memories: Shaped<Memories>; all: Shaped<AllMemories>; openMemory: string | null; openAll: string | null; recalls: Shaped<Recall[]>; openRecall: string | null; mode: Mode }
+    'peer-thread-mark': { shared: Shared; board: Shaped<Board>; memories: Shaped<Memories>; all: Shaped<AllMemories>; openMemory: string | null; openAll: string | null; recalls: Shaped<Recall[]>; openRecall: string | null; mode: Mode; signals: Shaped<Record<string, CollisionSignal>>; collideOff: boolean }
   }
 }

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@webinson/peer",
-  "version": "0.4.16",
-  "description": "Share chosen Claude Code threads with your team: who has agents running and on what.",
+  "version": "0.4.18",
+  "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": "bin/peer.mjs",
+    "peer-codex": "mod/codex/client/run.sh"
   },
   "files": [
     "bin",