@webinson/peer 0.4.14 → 0.4.16

package/README.md

@@ -18,9 +18,19 @@ In a Claude Code thread:
 - `/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.
-- In a shared thread a band above the prompt says `Peer <workspace>` with `/peer stop` to click; after a stop it
-  turns gray with `/peer start`. It is a Claude Code plugin in this package (`mod/`) that `peer install` adds;
-  the desktop app draws it only while you type or a turn runs.
+- 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; 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
+  that is not shared runs without OpenViking. What a thread was already given stays in it after a switch. The
+  band is a Claude Code plugin in this package (`mod/`) that `peer install` adds; the desktop app draws it only
+  while you type or a turn runs.
 - A shared thread's title starts with `● Peer · `, so it stands out in Claude Code's session list; the mark comes
   back if Claude Code renames the thread, and `/peer stop` takes it off.
 - `/peer-list` lists the shared threads by repository, then by person, with each thread's branch and

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

@@ -1,6 +1,6 @@
 {
   "name": "peer-thread-mark",
-  "version": "0.4.14",
+  "version": "0.4.16",
   "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,7 +1,7 @@
 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, Recall, RecallItem, Thread } from '../types'
+import type { AllMemories, AllQuery, Board, 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`;
@@ -28,6 +28,8 @@ const RECALLS_KEPT = 30
 const recalls = atom({ plugin: 'peer-thread-mark', key: 'recalls' } as const, [], { shape: 'recalls-1' })
 // The one prompt whose recall line is open, by its message id.
 const openRecall = atom({ plugin: 'peer-thread-mark', key: 'openRecall' } as const, null)
+// The band's memory mode for this thread: Elephant remembers, Jellyfish forgets.
+const mode = atom({ plugin: 'peer-thread-mark', key: 'mode' } as const, 'elephant')
 
 // Peer's team memory block: `- [verified pitfall] Title`, a line of text, then `(who, date, uri)`.
 function teamItems(context: string): RecallItem[] {
@@ -190,8 +192,73 @@ async function refresh($: EngineInterface) {
   if (before?.workspace !== now?.workspace || before?.isShared !== now?.isShared) {
     await update($, shared, () => now)
   }
+  await applyMemory($)
 }
 
+// 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'
+async function memoryUse($: EngineInterface): Promise<MemoryMode> {
+  if (!(await read($, shared))?.isShared) return 'own'
+  return (await read($, mode)) === 'elephant' ? 'openviking' : 'none'
+}
+let appliedMemory: MemoryMode | undefined
+// The thread's transcript, as the classic hooks hand it over; OpenViking counts its turns from it.
+let transcriptPath: string | undefined
+
+// OpenViking keeps how many of a thread's turns it has captured ($TMPDIR/openviking-cc-capture-state/<session>.json)
+// and takes everything after them at the next turn end. Turned on with Use Elephant, it would take the turns from
+// Inactive or Jellyfish too, so the count moves to the turns there are now, counted by OpenViking's own reader.
+const SKIP_TO_NOW = `
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
+import { homedir, tmpdir } from 'node:os'
+import { join } from 'node:path'
+const [id, transcript, cwd] = process.argv.slice(1)
+const installed = JSON.parse(readFileSync(join(homedir(), '.claude/plugins/installed_plugins.json'), 'utf-8'))
+const root = (installed.plugins?.['openviking-memory@openviking'] ?? []).map(e => e.installPath).find(p => p && existsSync(join(p, 'scripts/cc-transcript.mjs')))
+if (!root || !existsSync(transcript)) process.exit(0)
+const { parseTranscript, extractCaptureTurns } = await import(join(root, 'scripts/cc-transcript.mjs'))
+const { loadConfig } = await import(join(root, 'scripts/config.mjs'))
+const turns = extractCaptureTurns(parseTranscript(readFileSync(transcript, 'utf-8')), loadConfig(cwd)).length
+const dir = join(tmpdir(), 'openviking-cc-capture-state')
+const file = join(dir, id.replace(/[^a-zA-Z0-9_-]/g, '_') + '.json')
+let state = {}
+try { state = JSON.parse(readFileSync(file, 'utf-8')) } catch {}
+if ((state.capturedTurnCount ?? 0) < turns) {
+  mkdirSync(dir, { recursive: true })
+  writeFileSync(file, JSON.stringify({ ...state, capturedTurnCount: turns, baselinedBy: 'peer-thread-mark', ts: Date.now() }))
+}
+`
+async function skipToNow($: EngineInterface) {
+  if (!transcriptPath) return
+  // The node that runs Peer's own hooks, from Claude Code's settings; any node on PATH where there is none.
+  const node = (await promptHook($).catch(() => undefined))?.[0]
+  const argv = [node && /node$/.test(node) ? node : 'node', '--input-type=module', '-e', SKIP_TO_NOW, await $.session.id(), transcriptPath, await $.session.cwd()]
+  await $.process.run(argv, { timeoutMs: 10_000 }).catch(() => {})
+}
+// The OpenViking plugin's hooks read these on every run, and $.env.set reaches every process the session starts
+// after it, so the switch holds for this thread's next prompt, turn end and compaction. Its MCP server, started
+// with the session, is held back by the tool.call hook instead.
+async function applyMemory($: EngineInterface) {
+  const use = await memoryUse($)
+  if (use === appliedMemory) return use
+  const isOn = use === 'openviking'
+  if (isOn && appliedMemory !== undefined) await skipToNow($)
+  await $.env.set('OPENVIKING_MEMORY_ENABLED', isOn ? '1' : '0')
+  await $.env.set('OPENVIKING_AUTO_RECALL', isOn ? '1' : undefined)
+  await $.env.set('OPENVIKING_AUTO_CAPTURE', isOn ? '1' : undefined)
+  // Claude Code's own memory goes out of the system prompt and the first message with Jellyfish, back without it.
+  if (appliedMemory !== undefined && (appliedMemory === 'none' || use === 'none')) {
+    $.ui.invalidate('prompt.section')
+    $.ui.invalidate('prompt.context')
+  }
+  appliedMemory = use
+  return use
+}
+// 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_'
+
 // 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'
 // The soft badge where a surface draws one (desktop, VS Code, mobile): a pale tint and the color as its text, both
@@ -386,7 +453,8 @@ function projects(people: { email: string; threads: Thread[] }[]) {
 
 // A press does what typing the command does: the CLI's own hook shares or stops the thread and says so.
 // (A plugin may not submit a prompt that starts with `/`, so the hook is run directly.)
-async function send($: EngineInterface, prompt: string) {
+// `said`, when given, is the toast in place of the CLI's own line, once the press is done; a failure still says why.
+async function send($: EngineInterface, prompt: string, said?: () => Promise<string>) {
   try {
     const argv = await promptHook($)
     if (!argv) {
@@ -396,11 +464,23 @@ async function send($: EngineInterface, prompt: string) {
     const input = { session_id: await $.session.id(), cwd: await $.env.get('PWD'), prompt }
     const { stdout } = await $.process.run(argv, { stdin: JSON.stringify(input), timeoutMs: 10_000 })
     const reason = JSON.parse(stdout.trim().split('\n').pop() || '{}').reason
-    if (reason) $.ui.toast(String(reason))
+    if (reason && !said) $.ui.toast(String(reason))
   } catch (error) {
     $.ui.toast(`Peer: ${error instanceof Error ? error.message : String(error)}`)
+    await refresh($)
+    return
   }
   await refresh($)
+  if (said) $.ui.toast(await said())
+}
+
+// What a press of the band leaves the thread with, in a toast that stands in for a tooltip: the desktop does not
+// follow the pointer over the band, so a hover hint cannot show there.
+async function memoryNote($: EngineInterface) {
+  const use = await memoryUse($)
+  if (use === 'openviking') return 'Elephant: PeerMemory recalls and saves from now on.'
+  if (use === 'none') return 'Jellyfish: no memory in this thread.'
+  return 'Inactive: not shared, Claude Code memory only.'
 }
 
 export const register: Register = on => {
@@ -440,10 +520,53 @@ export const register: Register = on => {
     return next(e)
   })
 
+  // A session's first hooks run with the switch already set: OpenViking's start hook lists memories unless Elephant.
+  on('classic.SessionStart', async ($, e, next) => {
+    transcriptPath = e.transcript_path || transcriptPath
+    await refresh($).catch(() => {})
+    const use = await memoryUse($)
+    const result = await next(e)
+    if (use === 'openviking' || !result?.additionalContext) return result
+    return { ...result, additionalContext: result.additionalContext.filter(text => !OPENVIKING_BLOCK.test(text)) }
+  })
+
+  on('tool.call', async ($, e, next) => {
+    if (e.tool.startsWith(OPENVIKING_TOOL) && (await memoryUse($)) !== 'openviking') {
+      return { deny: 'PeerMemory is off in this thread. Use Elephant turns it on.' }
+    }
+    return next(e)
+  })
+
+  // Jellyfish: no memory of Claude Code's own either, neither its instructions nor the memory files it loads.
+  on('prompt.section', { name: 'memory' }, async ($, e, next) => ((await memoryUse($)) === 'none' ? { text: null } : next(e)))
+  on('prompt.context', async ($, e, next) => {
+    const result = await next(e)
+    const files = (e.instructionFiles ?? []).filter(file => file.kind === 'memory')
+    if (!files.length || (await memoryUse($)) !== 'none') return result
+    const blocks = result.blocks.map(block => {
+      if (block.name !== 'claudeMd') return block
+      let text = block.text
+      for (const file of files) {
+        const at = text.indexOf(`Contents of ${file.path}`)
+        if (at < 0) continue
+        const end = text.indexOf('\n\nContents of ', at + 1)
+        text = text.slice(0, at) + (end < 0 ? '' : text.slice(end + 2))
+      }
+      return { ...block, text }
+    })
+    return { ...result, blocks }
+  })
+
   // What reached the model with a prompt: the hooks beneath (Peer's from settings, OpenViking's plugin) answer
   // first, then the mod reads their additionalContext and keeps it for the prompt's row. It changes nothing.
   on('classic.UserPromptSubmit', async ($, e, next) => {
-    const result = await next(e)
+    transcriptPath = e.transcript_path || transcriptPath
+    await refresh($).catch(() => {})
+    const use = await memoryUse($)
+    let result = await next(e)
+    if (use !== 'openviking' && result?.additionalContext) {
+      result = { ...result, additionalContext: result.additionalContext.filter(text => !OPENVIKING_BLOCK.test(text)) }
+    }
     try {
       const context = (result?.additionalContext ?? []).join('\n')
       const items = [...teamItems(context), ...mineItems(context)]
@@ -562,7 +685,7 @@ export const register: Register = on => {
             {nearHere.map((memory, index) => savedCard(memory, fromHere.length + index))}
             {recalled.map(recallCard)}
             {asked.map((use, index) =>
-              card(`a-${e.requestId}-${index}`, 'Asked', <Text bold wrap="truncate-end">{use.items[0] ?? use.kind}</Text>, clock(use.at), `OpenViking ${use.kind}`),
+              card(`a-${e.requestId}-${index}`, 'Asked', <Text bold wrap="truncate-end">{use.items[0] ?? use.kind}</Text>, clock(use.at), `PeerMemory ${use.kind}`),
             )}
           </Box>
         )}
@@ -583,23 +706,72 @@ export const register: Register = on => {
     const total = saved && 'saves' in saved ? memoryCount(saved.saves) : undefined
     if (e.props.hasSurvey || (now === null && total === undefined)) return next(e)
     const isShared = now?.isShared ?? false
+    const kind = await read($, mode)
 
     const { Box, Button, Text } = $.ui.resolve(e)
+    // A hint is the band's tooltip: one line in the free space of the band's own row, between the modes and the
+    // status, hidden until the pointer is on its control, so the band never has to grow for it. The control's zone
+    // Box and its Button both join the hint's scope, as a desktop's native button may take the pointer from the Box
+    // around it; the zones carry keys of their own, apart from their Buttons'.
+    const hint = (scope: string, text: string) => (
+      <Box key={`hint-${scope}`} display="none" flexGrow={1} hover={{ scope, display: 'flex' }}>
+        <Text dimColor size="footnote" wrap="truncate-end">{text}</Text>
+      </Box>
+    )
+    const count = total === undefined ? '–' : String(total)
+    const noun = total === 1 ? 'memory' : 'memories'
+    // A mode is lit only while the thread is shared: pressing the lit one stops sharing (Inactive), pressing
+    // either while Inactive picks it and shares again (Active), pressing the other while Active only switches.
+    const pick = async (key: Mode) => {
+      const said = () => memoryNote($)
+      if (isShared && kind === key) return send($, '/peer stop', said)
+      await update($, mode, () => key)
+      if (!isShared) return send($, '/peer', said)
+      await applyMemory($)
+      $.ui.toast(await said())
+    }
+    // A desktop draws a Button's label as its own native button and leaves Text inside it unstyled, so the lit
+    // mode is the primary button and the other the secondary; the terminal draws the primary in the accent color.
+    const animal = (key: Mode, name: string) => (
+      <Box key={`zone-${key}`} gap={1} alignItems="center" hover={{ scope: `peer-${key}` }}>
+        <Button key={key} label={name} variant={isShared && kind === key ? 'primary' : 'secondary'} hover={{ scope: `peer-${key}` }} onPress={() => void pick(key)} />
+      </Box>
+    )
+    const modeHint = (key: Mode, about: string) =>
+      `${about} ${isShared && kind === key ? 'Press again to stop.' : isShared ? 'Press to switch.' : 'Press to share with it.'}`
+    const hints = {
+      memory: total ? 'What this thread saved.' : 'Nothing saved yet.',
+      elephant: modeHint('elephant', 'Recall and save with PeerMemory.'),
+      jellyfish: modeHint('jellyfish', 'No memory at all.'),
+      share: isShared ? 'Shared with your workspace. Press to stop.' : 'Not shared. Press to share.',
+    }
     return (
-      <Box gap={2}>
-        <Button key="memory" label={total === undefined ? 'Memory' : `Memory, ${total}`} plain onPress={async () => { memoryOpen = await openThread($) }}>
-          <Text bold>{'Memory '}</Text>
-          <Text backgroundColor={total ? 'suggestion' : 'inactive'} color="inverseText" bold tabular>
-            {` ${total ?? '–'} `}
-          </Text>
-        </Button>
-        <Button
-          key="toggle"
-          label={isShared ? '/peer stop' : '/peer start'}
-          plain
-          dimColor
-          onPress={() => send($, isShared ? '/peer stop' : '/peer')}
-        />
+      <Box flexDirection="column">
+        <Box width="100%" justifyContent="space-between" gap={2}>
+          <Box gap={2}>
+            <Box key="zone-memory" gap={1} alignItems="center" hover={{ scope: 'peer-memory' }}>
+              <Button key="memory" label={`${count} ${noun}`} plain hover={{ scope: 'peer-memory' }} onPress={async () => { memoryOpen = await openThread($) }}>
+                <Text bold tabular>{count}</Text>
+                <Text>{` ${noun}`}</Text>
+              </Button>
+            </Box>
+            <Box gap={1}>
+              {animal('elephant', 'Use Elephant')}
+              {animal('jellyfish', 'Use Jellyfish')}
+            </Box>
+          </Box>
+          <Box flexGrow={1} flexShrink={1} paddingX={2}>
+            {e.surface === 'terminal' && hint('peer-memory', hints.memory)}
+            {e.surface === 'terminal' && hint('peer-elephant', hints.elephant)}
+            {e.surface === 'terminal' && hint('peer-jellyfish', hints.jellyfish)}
+            {e.surface === 'terminal' && hint('peer-share', hints.share)}
+          </Box>
+          {/* The dot is Text beside the Button, where both surfaces keep its color. */}
+          <Box key="zone-toggle" gap={1} alignItems="center" hover={{ scope: 'peer-share' }}>
+            <Text color={isShared ? 'success' : 'inactive'}>{isShared ? '●' : '○'}</Text>
+            <Button key="toggle" label={isShared ? 'Active' : 'Inactive'} plain dimColor={!isShared} hover={{ scope: 'peer-share' }} onPress={() => send($, isShared ? '/peer stop' : '/peer', () => memoryNote($))} />
+          </Box>
+        </Box>
       </Box>
     )
   })
@@ -755,7 +927,7 @@ export const register: Register = on => {
       return status(now?.error ? <Text color="error">{`Peer: your memories did not load (${now.error})`}</Text> : <Text dimColor>Loading…</Text>)
     }
     if (now.error) return status(<Text color="error">{`Peer: your memories did not load (${now.error})`}</Text>)
-    if (!found.connected) return status(<Text dimColor>{`No personal OpenViking here (${found.reason}).`}</Text>)
+    if (!found.connected) return status(<Text dimColor>{`No PeerMemory here (${found.reason}).`}</Text>)
     if (found.total === 0) return status(<Text dimColor>{ask.text ? 'Nothing has those words.' : 'No memories yet.'}</Text>)
 
     const words = searchWords(ask.text)
@@ -859,7 +1031,7 @@ export const register: Register = on => {
         </Box>
       )
     }
-    if (!now.connected) return <Text dimColor>{`No personal OpenViking here (${now.reason}).`}</Text>
+    if (!now.connected) return <Text dimColor>{`No PeerMemory here (${now.reason}).`}</Text>
 
     const groups = sections(now.saves)
     const total = groups.check.length + groups.added.length + groups.updated.length + groups.removed.length
@@ -928,7 +1100,7 @@ export const register: Register = on => {
     // Where memory went into the thread, oldest first: one line each, what and when; a press opens which memories,
     // and Show in thread where it came with a message.
     const uses = now.uses ?? []
-    const USE_WORDS: Record<string, string> = { start: 'At the start', resume: 'On resume', prompt: 'With your message', tool: 'Asked OpenViking' }
+    const USE_WORDS: Record<string, string> = { start: 'At the start', resume: 'On resume', prompt: 'With your message', tool: 'Asked PeerMemory' }
     const useRow = (use: MemoryUse, index: number) => {
       const id = `use-${index}`
       const isOpen = open === id
@@ -976,7 +1148,7 @@ export const register: Register = on => {
             {uses.map(useRow)}
           </Box>
         )}
-        {total === 0 && <Text dimColor>Nothing saved yet. OpenViking saves after longer turns.</Text>}
+        {total === 0 && <Text dimColor>Nothing saved yet. PeerMemory saves after longer turns.</Text>}
         {section('Check', groups.check, true)}
         {section('New', groups.added)}
         {section('Updated', groups.updated)}

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

@@ -26,11 +26,27 @@ test('the band counts the thread\'s memories, names no workspace, and opens the
   on('fs.read', (_, e) => {
     const path = String((e as { path?: string }).path ?? '')
     if (path.endsWith('settings.json')) return { value: JSON.stringify(settings) } as never
-    if (path.endsWith('/sessions/s1')) return { value: JSON.stringify({ workspace: 'hotovo' }) } as never
+    if (path.endsWith('/sessions/s1') && !stopped) return { value: JSON.stringify({ workspace: 'hotovo' }) } as never
     throw new Error('none')
   })
-  on('process.run', () => ({ value: { stdout: JSON.stringify(SAVES), stderr: '', exitCode: 0 } }) as never)
+  // The CLI's hook: `/peer stop` removes the session file, `/peer` writes it back.
+  let stopped = false
+  const sent: string[] = []
+  on('process.run', (_, e) => {
+    const stdin = (e as { init?: { stdin?: string } }).init?.stdin
+    const prompt = stdin ? (JSON.parse(stdin) as { prompt?: string }).prompt : undefined
+    if (prompt) {
+      sent.push(prompt)
+      stopped = prompt === '/peer stop'
+      return { value: { stdout: '{}', stderr: '', exitCode: 0 } } as never
+    }
+    return { value: { stdout: JSON.stringify(SAVES), stderr: '', exitCode: 0 } } as never
+  })
   on('session.id', () => ({ value: 's1' }) as never)
+  on('env.set', () => ({ value: {} }) as never)
+  on('ui.invalidate', () => ({ value: undefined }) as never)
+  const toasts: string[] = []
+  on('ui.toast', (_, e) => { toasts.push(String((e as { text?: string }).text ?? '')); return { value: undefined } as never })
   on('clock.now', () => ({ value: 1 }) as never)
   const opened: string[] = []
   on('ui.open', (_, e) => { opened.push((e as { id: string }).id); return { value: { isPlaced: true } } as never })
@@ -43,7 +59,9 @@ test('the band counts the thread\'s memories, names no workspace, and opens the
 
   // Before the thread's memories have loaded the square holds a dash; a press opens the pane and loads them.
   const before = await $.ui.mount({ ...BAND, surface: 'desktop' })
-  expect((await before.findAll({ type: 'Text' })).map(t => t.text)).toEqual(['Memory ', ' – '])
+  const first = (await before.findAll({ type: 'Text' })).map(t => t.text)
+  expect(first.slice(0, 2)).toEqual(['–', ' memories'])
+  expect(first).toContain('●')
   await before.press({ key: 'memory' } as never)
   await before.unmount()
   expect(opened).toEqual(['peer-thread-memories'])
@@ -52,8 +70,33 @@ test('the band counts the thread\'s memories, names no workspace, and opens the
     const ui = await $.ui.mount({ ...BAND, surface })
     const texts = (await ui.findAll({ type: 'Text' })).map(t => t.text)
     // New, updated once (two saves of one memory), the removed one gone: 2.
-    expect(texts.slice(0, 2)).toEqual(['Memory ', ' 2 '])
+    expect(texts.slice(0, 2)).toEqual(['2', ' memories'])
     expect(texts.some(t => t.includes('hotovo'))).toBe(false)
     await ui.unmount()
   }
+
+  // Elephant is lit while shared; pressing Jellyfish only switches, pressing the lit one again stops sharing,
+  // and pressing it while Inactive shares again.
+  const lit = async (ui: { findAll: (q: { type: 'Button' }) => Promise<{ props?: { label?: string; variant?: string } }[]> }) =>
+    (await ui.findAll({ type: 'Button' })).filter(b => b.props?.variant === 'primary').map(b => b.props?.label)
+  const modes = await $.ui.mount({ ...BAND, surface: 'desktop' })
+  expect(await lit(modes as never)).toEqual(['Use Elephant'])
+  await modes.press({ key: 'jellyfish' } as never)
+  expect(await lit(modes as never)).toEqual(['Use Jellyfish'])
+  expect(sent).toEqual([])
+  await modes.press({ key: 'jellyfish' } as never)
+  expect(sent).toEqual(['/peer stop'])
+  let texts = (await modes.findAll({ type: 'Text' })).map(t => t.text)
+  expect(texts).toContain('○')
+  expect(await modes.findAll({ type: 'Button' } as never)).toContainEqual(expect.objectContaining({ props: expect.objectContaining({ label: 'Inactive' }) }))
+  expect(await lit(modes as never)).toEqual([])
+  await modes.press({ key: 'jellyfish' } as never)
+  expect(sent).toEqual(['/peer stop', '/peer'])
+  texts = (await modes.findAll({ type: 'Text' })).map(t => t.text)
+  expect(texts).toContain('●')
+  expect(await lit(modes as never)).toEqual(['Use Jellyfish'])
+  // The desktop does not follow the pointer over the band, so each press says what the thread now uses, as a toast.
+  expect(toasts.at(-1)).toBe('Jellyfish: no memory in this thread.')
+  expect((await modes.findAll({ type: 'Box' } as never) as { key?: string }[]).some(b => b.key === 'hint-peer-jellyfish')).toBe(false)
+  await modes.unmount()
 })

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

@@ -0,0 +1,99 @@
+import { expect, test } from 'claude-code/testing'
+
+const BAND = {
+  plugin: 'peer-thread-mark',
+  component: 'AbovePrompt',
+  props: { hasSurvey: false, isWorking: false, maxRows: 12 },
+} as const
+
+const MEMORY_FILE = '/home/.claude/projects/p/memory/MEMORY.md'
+const CLAUDE_MD = `Contents of /home/.claude/CLAUDE.md (user's private global instructions):\n\nBe brief.\n\nContents of ${MEMORY_FILE} (user's auto-memory):\n\n- a fact`
+
+test('Elephant turns OpenViking on, Inactive keeps Claude Code memory alone, Jellyfish keeps none', async ($, on) => {
+  const settings = { hooks: { UserPromptSubmit: [{ hooks: [{ command: '"/n/node" "/p/peer.mjs" hook prompt # peer-hook' }] }] } }
+  // The CLI's hook: `/peer stop` removes the session file, `/peer` writes it back.
+  let stopped = 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(settings) } as never
+    if (path.endsWith('/sessions/s1') && !stopped) return { value: JSON.stringify({ workspace: 'hotovo' }) } as never
+    throw new Error('none')
+  })
+  const runs: string[][] = []
+  on('process.run', (_, e) => {
+    runs.push([...(e as { argv: string[] }).argv])
+    const stdin = (e as { init?: { stdin?: string } }).init?.stdin
+    const prompt = stdin ? (JSON.parse(stdin) as { prompt?: string }).prompt : undefined
+    if (prompt) stopped = prompt === '/peer stop'
+    return { value: { stdout: prompt ? '{}' : JSON.stringify({ connected: true, saves: [] }), stderr: '', exitCode: 0 } } as never
+  })
+  const env: Record<string, string | undefined> = {}
+  on('env.set', (_, e) => {
+    const { name, value } = e as { name: string; value?: string }
+    env[name] = value
+    return { 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 }))
+  // Beneath the mod: OpenViking's recall and a hook of the person's own, a tool that answers, core's memory.
+  on('classic.UserPromptSubmit', () => ({ additionalContext: ['<openviking-context>- [memory 80%] x</openviking-context>', 'kept'] }) as never)
+  let toolRuns = 0
+  on('tool.call', () => { toolRuns++; return { result: { content: 'ok' } } as never })
+  on('prompt.section', () => ({ text: 'how memory works' }) as never)
+  on('prompt.context', (_, e) => ({ blocks: (e as { blocks: unknown[] }).blocks }) as never)
+
+  const context = () =>
+    $.prompt.context({
+      blocks: [{ name: 'claudeMd', text: CLAUDE_MD }],
+      instructionFiles: [{ path: MEMORY_FILE, kind: 'memory', content: '- a fact' }],
+    })
+  const search = () => $.tool.call({ tool: 'mcp__plugin_openviking-memory_openviking__search', query: 'x' } as never)
+  const recalled = async () => (await $.classic.UserPromptSubmit({ prompt: 'hi', transcript_path: '/t/s1.jsonl' } as never)).additionalContext
+  const cursorMoves = () => runs.filter(argv => argv.includes('--input-type=module'))
+
+  await $.session.start({ cwd: '/', surface: 'desktop', isInteractive: true })
+
+  // Shared, with Elephant: OpenViking on, its recall reaches the model, its tools run, Claude Code's memory stays.
+  expect(env.OPENVIKING_MEMORY_ENABLED).toBe('1')
+  expect(env.OPENVIKING_AUTO_CAPTURE).toBe('1')
+  expect(await recalled()).toHaveLength(2)
+  await search()
+  expect(toolRuns).toBe(1)
+  expect((await $.prompt.section({ name: 'memory', text: 'how memory works' })).text).toBe('how memory works')
+
+  // Jellyfish: OpenViking off, its recall and tools held back, and no Claude Code memory either.
+  const band = await $.ui.mount({ ...BAND, surface: 'desktop' })
+  await band.press({ key: 'jellyfish' } as never)
+  expect(env.OPENVIKING_MEMORY_ENABLED).toBe('0')
+  expect(env.OPENVIKING_AUTO_CAPTURE).toBeUndefined()
+  expect(await recalled()).toEqual(['kept'])
+  await search()
+  expect(toolRuns).toBe(1)
+  expect((await $.prompt.section({ name: 'memory', text: 'how memory works' })).text).toBeNull()
+  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(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')
+  expect((await context()).blocks.find(b => b.name === 'claudeMd')?.text).toContain('a fact')
+
+  // Use Elephant from Inactive shares again, with OpenViking on, and its capture starts at the turns there are now,
+  // so what was said under Jellyfish and Inactive is never saved. Starting with Elephant moved nothing.
+  expect(cursorMoves()).toHaveLength(0)
+  await band.press({ key: 'elephant' } as never)
+  expect(env.OPENVIKING_MEMORY_ENABLED).toBe('1')
+  expect(cursorMoves()).toHaveLength(1)
+  expect(cursorMoves()[0]?.slice(-3)).toEqual(['s1', '/t/s1.jsonl', '/repo'])
+  await band.unmount()
+})

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

@@ -29,7 +29,12 @@ test('a prompt shows under it what Peer and OpenViking recalled for it, and chan
   on('classic.UserPromptSubmit', () => ({ additionalContext: context }) as never)
   on('ui.render', (_, e) => ({ type: 'Text', props: {}, children: [String((e as { props: { text: string } }).props.text)] }) as never)
   on('env.get', () => ({ value: '/home' }) as never)
-  on('fs.read', () => { throw new Error('none') })
+  // A thread shared with Use Elephant: OpenViking's recall and teammates' pages reach the model.
+  on('fs.read', (_, e) => {
+    if (String((e as { path?: string }).path ?? '').endsWith('/sessions/s1')) return { value: JSON.stringify({ workspace: 'acme' }) } as never
+    throw new Error('none')
+  })
+  on('env.set', () => ({ value: {} }) as never)
   on('session.id', () => ({ value: 's1' }) as never)
   on('clock.now', () => ({ value: 1 }) as never)
   let copied = ''

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

@@ -118,7 +118,7 @@ test('a message shows under it what OpenViking saved from it, and what it only u
   olderTexts = (await older.findAll({ type: 'Text' })).map(t => t.text)
   expect(olderTexts).toContain('The partner API takes at most 100 items')
   expect(olderTexts).toContain(' Asked ')
-  expect(olderTexts).toContain('OpenViking search')
+  expect(olderTexts).toContain('PeerMemory search')
   await older.unmount()
 
   // The /peer-thread pane lists where memory went into the thread; one with a message can show it.
@@ -130,7 +130,7 @@ test('a message shows under it what OpenViking saved from it, and what it only u
   expect(usedTexts).toContain('Used')
   expect(usedTexts).toContain('At the start · 2 memories listed')
   expect(usedTexts).toContain("With your message · 1 teammate's page")
-  expect(usedTexts).toContain('Asked OpenViking: search')
+  expect(usedTexts).toContain('Asked PeerMemory: search')
   await usedPane.press({ key: 'use-0' } as never)
   expect((await usedPane.findAll({ type: 'Text' })).map(t => t.text)).toContain('· This Mac')
   expect((await usedPane.findAll({ type: 'Button' })).some(b => b.key === 'use-0-show')).toBe(false)

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

@@ -63,8 +63,11 @@ export type AllMemories = { ask: AllQuery; loading: boolean; found?: AllFound; e
 export type RecallItem = { from: 'team' | 'mine'; title: string; detail: string; uri: string }
 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'
+
 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 }
+    '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 }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webinson/peer",
-  "version": "0.4.14",
+  "version": "0.4.16",
   "description": "Share chosen Claude Code threads with your team: who has agents running and on what.",
   "license": "MIT",
   "type": "module",