@webinson/peer 0.4.14 → 0.4.15

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; 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`).
+    `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.15",
   "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
@@ -440,10 +507,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: 'OpenViking is off in this thread: only Use Elephant in the Peer band 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)]
@@ -583,23 +693,59 @@ 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: a line under the controls, hidden until the pointer is on its control's scope.
+    const hint = (scope: string, text: string) => (
+      <Box key={`hint-${scope}`} display="none" 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) => {
+      if (isShared && kind === key) return send($, '/peer stop')
+      await update($, mode, () => key)
+      if (isShared) await applyMemory($)
+      else await send($, '/peer')
+    }
+    // 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={key} hover={{ scope: `peer-${key}` }}>
+        <Button key={key} label={name} variant={isShared && kind === key ? 'primary' : 'secondary'} onPress={() => void pick(key)} />
+      </Box>
+    )
+    const modeHint = (key: Mode, about: string) =>
+      `${about} ${isShared && kind === key ? 'Press again to turn Peer off for this thread.' : isShared ? 'Press to switch.' : 'Press to turn Peer on with it.'}`
     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="memory" hover={{ scope: 'peer-memory' }}>
+              <Button key="memory" label={`${count} ${noun}`} plain 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>
+          {/* The dot is Text beside the Button, where both surfaces keep its color. */}
+          <Box key="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} onPress={() => send($, isShared ? '/peer stop' : '/peer')} />
+          </Box>
+        </Box>
+        {hint('peer-memory', total ? `What this thread has saved to your memory. Open the list.` : 'Nothing saved from this thread yet. Open the list.')}
+        {hint('peer-elephant', modeHint('elephant', 'Elephant never forgets: this thread saves what it learns and recalls your memories.'))}
+        {hint('peer-jellyfish', modeHint('jellyfish', 'Jellyfish lives in the moment: this thread saves nothing and recalls nothing.'))}
+        {hint('peer-share', isShared ? 'Shared with your Peer workspace: teammates see this thread. Press to stop sharing (/peer stop).' : 'Not shared. Press to share this thread with your Peer workspace (/peer).')}
       </Box>
     )
   })

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

@@ -26,11 +26,25 @@ 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)
   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 +57,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 +68,30 @@ 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'])
+  await modes.unmount()
 })

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

@@ -0,0 +1,98 @@
+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('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/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.15",
   "description": "Share chosen Claude Code threads with your team: who has agents running and on what.",
   "license": "MIT",
   "type": "module",