@webinson/peer 0.4.23 → 0.4.25

package/README.md

@@ -14,9 +14,10 @@ and the commands `/peer` and `/peer-list` in `~/.claude/commands`.
 
 In a Claude Code thread:
 
-- `/peer` shares this thread in your workspace. Its turn only confirms the sharing and carries no memory at all,
-  so a thread you then switch to Jellyfish holds none from the start.
-- `/peer jellyfish` and `/peer elephant` share it in that memory mode at once.
+- `/peer` shares this thread in your workspace. With the band installed it is answered without a turn of the
+  model, so nothing reaches the agent yet: Claude Code builds a thread's first context before any command runs,
+  and a thread you then switch to Jellyfish holds no memory from the start.
+- `/peer jellyfish` and `/peer elephant` share it in that memory mode at once, also without a turn.
 - `/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.
@@ -27,6 +28,7 @@ In a Claude Code thread:
     thread goes, on top of Claude Code's own memory. It saves only the turns from the moment it was chosen.
   - **Inactive** (not shared): Claude Code's own memory alone; PeerMemory stays off.
   - **Use Jellyfish** (shared): no memory at all, neither PeerMemory nor Claude Code's own (`MEMORY.md`).
+    The agent cannot read, search or change Claude Code's memory files with a tool either.
     `CLAUDE.md` instructions stay. Claude Code puts `MEMORY.md` into a thread's first message, so a thread meant to
     hold none starts with `/peer` (or `/peer jellyfish`): a first message with work in it already carries it.
 

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

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

@@ -276,6 +276,9 @@ async function applyMemory($: EngineInterface) {
 // What OpenViking's recall and Peer's team memory add to a prompt, left out where the thread keeps OpenViking off.
 const OPENVIKING_BLOCK = /<openviking-context|<teammates-project-knowledge/
 const OPENVIKING_TOOL = 'mcp__plugin_openviking-memory_'
+// Claude Code's own memory files, in a tool's input however it is written: a path, a glob, a shell command that
+// changes into ~/.claude first or looks for MEMORY.md there. A call that names both is held back.
+const usesMemoryFiles = (input: string) => /\.claude(?=[\\/"'\s]|$)/.test(input) && /memory/i.test(input)
 
 // The memory badge's color: an explicit value, as a surface may not know a theme key; it reads on light and dark.
 const SAVED_COLOR = '#8b5cf6'
@@ -711,6 +714,11 @@ export const register: Register = on => {
     if (e.tool.startsWith(OPENVIKING_TOOL) && (await memoryUse($)) !== 'openviking') {
       return { deny: 'PeerMemory is off in this thread. Use Elephant turns it on.' }
     }
+    // Jellyfish keeps Claude Code's memory files out of the context, and an agent that knows where they live
+    // (~/.claude/projects/<project>/memory) does not read, search or write them with a tool either.
+    if (usesMemoryFiles(JSON.stringify(e)) && (await memoryUse($)) === 'none') {
+      return { deny: "Jellyfish: this thread uses no memory, Claude Code's memory files included. Use Elephant or Inactive brings them back." }
+    }
     return next(e)
   })
 
@@ -955,6 +963,30 @@ export const register: Register = on => {
 
   // /peer-list opens the pane and runs no command: the prompt never reaches the CLI's hook, so Claude Code shows
   // no "hook blocked your prompt" card. Where no surface can seat a pane, the command runs as before.
+  // `/peer`, `/peer jellyfish`, `/peer elephant` share the thread here, with no turn of the model: Claude Code
+  // builds a conversation's first context before any command runs, so a turn would carry MEMORY.md before the mode
+  // is known. Without a turn nothing is sent, and the first real message is built in the mode picked here.
+  on('command.run', { command: 'peer' }, async ($, e, next) => {
+    const word = e.args.trim().toLowerCase()
+    if (word !== '' && word !== 'jellyfish' && word !== 'elephant') return next(e)
+    try {
+      const argv = await promptHook($)
+      if (!argv) return next(e)
+      const input = { session_id: await $.session.id(), cwd: await $.env.get('PWD'), prompt: '/peer' }
+      const { stdout } = await $.process.run(argv, { stdin: JSON.stringify(input), timeoutMs: 10_000 })
+      const answer = JSON.parse(stdout.trim().split('\n').pop() || '{}') as { reason?: string; hookSpecificOutput?: { additionalContext?: string } }
+      const line = (answer.hookSpecificOutput?.additionalContext ?? '').split('\n').find(l => l.startsWith('Peer: this thread is shared'))
+      if (!line) return { text: answer.reason ?? 'Peer: the thread was not shared; `peer doctor` says why.' }
+      if (word) await update($, mode, () => word)
+      await refresh($)
+      $.ui.invalidate('prompt.section')
+      $.ui.invalidate('prompt.context')
+      return { text: `${line}\n${await memoryNote($)}` }
+    } catch {
+      return next(e)
+    }
+  })
+
   on('command.run', { command: 'peer-list' }, async ($, e, next) => {
     await load($)
     const opened = await $.ui.open({ id: PANE, title: 'Peer' })

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

@@ -77,12 +77,24 @@ test('Elephant turns OpenViking on, Inactive keeps Claude Code memory alone, Jel
   await search()
   expect(toolRuns).toBe(1)
   expect((await $.prompt.section({ name: 'memory', text: 'how memory works' })).text).toBeNull()
+  // Nor its memory files, read, searched or changed with a tool; other files under ~/.claude still are.
+  const denied = async (input: object) => {
+    const before = toolRuns
+    const result = (await $.tool.call(input as never)) as { deny?: string }
+    return toolRuns === before && Boolean(result?.deny)
+  }
+  expect(await denied({ tool: 'Read', file_path: '/home/.claude/projects/p/memory/peer-proof.md' })).toBe(true)
+  expect(await denied({ tool: 'Bash', command: 'cd ~/.claude && cat projects/p/memory/MEMORY.md' })).toBe(true)
+  expect(await denied({ tool: 'Grep', pattern: '12/13', path: '/home/.claude/projects' , glob: '**/memory/*.md' })).toBe(true)
+  expect(await denied({ tool: 'Read', file_path: '/home/.claude/settings.json' })).toBe(false)
+  expect(await denied({ tool: 'Read', file_path: '/repo/.claude-plugin/memory.json' })).toBe(false)
   const kept = (await context()).blocks.find(b => b.name === 'claudeMd')?.text ?? ''
   expect(kept).toContain('Be brief.')
   expect(kept).not.toContain('a fact')
 
   // Pressing the lit Jellyfish stops sharing: Inactive, OpenViking still off, Claude Code's own memory back.
   await band.press({ key: 'jellyfish' } as never)
+  expect(await denied({ tool: 'Read', file_path: '/home/.claude/projects/p/memory/peer-proof.md' })).toBe(false)
   expect(env.OPENVIKING_MEMORY_ENABLED).toBe('0')
   expect(await recalled()).toEqual(['kept'])
   expect((await $.prompt.section({ name: 'memory', text: 'how memory works' })).text).toBe('how memory works')
@@ -168,3 +180,56 @@ test('a bare /peer turn carries no memory; the mode picked after it decides the
   await $.prompt.submit({ text: '/peer fix it', command: { name: 'peer', args: 'fix it' } } as never)
   expect(await memory()).toEqual({ section: null, fact: false })
 })
+
+test('/peer jellyfish shares the thread with no turn of the model, so its first message is built without memory', async ($, on) => {
+  let shared = false
+  const prompts: string[] = []
+  on('env.get', () => ({ value: '/home' }) as never)
+  on('fs.read', (_, e) => {
+    const path = String((e as { path?: string }).path ?? '')
+    if (path.endsWith('settings.json')) return { value: JSON.stringify({ hooks: { UserPromptSubmit: [{ hooks: [{ command: '"/n/node" "/p/peer.mjs" hook prompt # peer-hook' }] }] } }) } as never
+    if (path.endsWith('/sessions/s1') && shared) return { value: JSON.stringify({ workspace: 'hotovo' }) } as never
+    throw new Error('none')
+  })
+  on('process.run', (_, e) => {
+    const stdin = (e as { init?: { stdin?: string } }).init?.stdin
+    const prompt = stdin ? (JSON.parse(stdin) as { prompt?: string }).prompt : undefined
+    if (prompt) {
+      prompts.push(prompt)
+      shared = true
+      const additionalContext = "[Peer's hook ran]\nPeer: this thread is shared in hotovo as peer @ main. /peer stop ends it.\nThe person typed /peer alone."
+      return { value: { stdout: JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext } }), stderr: '', exitCode: 0 } } as never
+    }
+    return { value: { stdout: JSON.stringify({ connected: true, saves: [] }), stderr: '', exitCode: 0 } } as never
+  })
+  on('env.set', () => ({ value: {} }) as never)
+  on('session.id', () => ({ value: 's1' }) as never)
+  on('session.cwd', () => ({ value: '/repo' }) as never)
+  on('clock.now', () => ({ value: 1 }) as never)
+  on('command.register', (_, e) => ({ value: { command: (e as { name: string }).name } }) as never)
+  on('ui.status', () => ({ value: undefined }) as never)
+  on('ui.invalidate', () => ({ value: undefined }) as never)
+  on('ui.toast', () => ({ value: undefined }) as never)
+  on('session.start', (_, e) => ({ cwd: e.cwd }))
+  let modelTurns = 0
+  on('command.run', () => { modelTurns++; return { text: '' } as never })
+  on('prompt.section', () => ({ text: 'how memory works' }) as never)
+  on('prompt.context', (_, e) => ({ blocks: (e as { blocks: unknown[] }).blocks }) as never)
+
+  await $.session.start({ cwd: '/', surface: 'desktop', isInteractive: true })
+  const said = await $.command.run({ command: 'peer', args: 'jellyfish' } as never)
+  expect(modelTurns).toBe(0)
+  expect(prompts).toEqual(['/peer'])
+  expect(String((said as { text?: string }).text)).toContain('Peer: this thread is shared in hotovo')
+  expect(String((said as { text?: string }).text)).toContain('Jellyfish')
+  expect((await $.prompt.section({ name: 'memory', text: 'how memory works' })).text).toBeNull()
+  const context = await $.prompt.context({
+    blocks: [{ name: 'claudeMd', text: CLAUDE_MD }],
+    instructionFiles: [{ path: MEMORY_FILE, kind: 'memory', content: '- a fact' }],
+  })
+  expect(context.blocks.find(b => b.name === 'claudeMd')?.text).not.toContain('a fact')
+
+  // A message after /peer is the person's work: the engine's command runs as before.
+  await $.command.run({ command: 'peer', args: 'fix the export' } as never)
+  expect(modelTurns).toBe(1)
+})

package/package.json

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