@webinson/peer 0.4.5 → 0.4.15

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 } from 'claude-code'
+import type { EngineInterface, Register, RenderChildren, RenderNode, RenderSurface } from 'claude-code'
 
-import type { AllMemories, AllQuery, Board, Memories, MemoryItem, MemoryRow, 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`;
@@ -23,6 +23,45 @@ const openMemory = atom({ plugin: 'peer-thread-mark', key: 'openMemory' } as con
 // The search pane: /peer-all lists all of the person's own memories, newest first, and searches their text.
 const ALL_PANE = 'peer-all-memories'
 const all = atom({ plugin: 'peer-thread-mark', key: 'all' } as const, null, { shape: 'all-2' })
+// What the hooks added to the session's last prompts, newest last; a prompt's row in the thread finds its own here.
+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[] {
+  const block = /<teammates-project-knowledge[^>]*>([\s\S]*?)<\/teammates-project-knowledge>/.exec(context)?.[1]
+  if (!block) return []
+  return block
+    .split(/\n(?=- \[)/)
+    .filter(entry => entry.startsWith('- ['))
+    .map(entry => {
+      const [head = '', ...rest] = entry.split('\n')
+      const kind = /^- \[([^\]]+)\]/.exec(head)?.[1] ?? ''
+      const by = /\(([^,]+), (\d{4}-\d{2}-\d{2})?, (viking:\/\/\S+)\)\s*$/.exec(entry)
+      return {
+        from: 'team' as const,
+        title: head.replace(/^- \[[^\]]+\]\s*/, '').trim(),
+        detail: [kind.split(' · ')[0], by?.[1], by?.[2]].filter(Boolean).join(' · '),
+        uri: by?.[3] ?? '',
+      }
+    })
+}
+
+// OpenViking's recall block: `- [memory 82%] <a memory's text or its address>`, one line each.
+function mineItems(context: string): RecallItem[] {
+  const block = /<openviking-context(?![^>]*source="startup")[^>]*>([\s\S]*?)<\/openviking-context>/.exec(context)?.[1]
+  if (!block) return []
+  return [...block.matchAll(/^- \[(\S+) (\d+)%\] (.+)$/gm)].map(([, kind, score, text = '']) => {
+    const isUri = text.startsWith('viking://')
+    const name = isUri ? (text.replace(/\/+$/, '').split('/').pop() ?? text).replace(/\.md$/, '').replace(/[_-]+/g, ' ') : text
+    return { from: 'mine' as const, title: snippet(name).slice(0, 120), detail: `${kind} · ${score}%`, uri: isUri ? text : '' }
+  })
+}
+
 // The one memory the search pane shows open, by its address.
 const openAll = atom({ plugin: 'peer-thread-mark', key: 'openAll' } as const, null)
 
@@ -153,8 +192,130 @@ 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
+// plain six-digit colors (a surface may refuse a whole drawing over a color with alpha).
+const SOFT_BACKGROUND = '#ede9fe'
+const SOFT_COLOR = '#6d28d9'
+// A memory's kind in a word, and a day as the card says it.
+const KIND_WORD: Record<string, string> = { events: 'event', entities: 'entity', preferences: 'preference', profile: 'profile' }
+function fullDay(at: string) {
+  const date = new Date(at)
+  return Number.isNaN(date.getTime()) ? '' : `${date.getDate()} ${MONTHS[date.getMonth()]} ${date.getFullYear()}`
+}
+
+// Show in thread: scroll the thread to the message where the surface lets a plugin scroll it (the terminal). The
+// desktop does not, so its own Find gets the message's words (picked by the CLI to be rare in the thread) by ⌘F, ⌘V,
+// and ⌘G for a later match; without the Mac's permission for that, the person is told the keys.
+async function showInThread($: EngineInterface, place: { messageId?: string; messageText?: string; messageMatch?: number }, surface: RenderSurface) {
+  const findIt = async () => {
+    if (!place.messageText) return $.ui.toast('Peer: this surface cannot scroll the thread to a message')
+    await $.ui.copy({ text: place.messageText, surface })
+    const match = place.messageMatch ?? 1
+    if (await findInApp($, match)) return
+    $.ui.toast(
+      match > 1
+        ? `Copied your message. Press ⌘F, ⌘V, then ⌘G ${match - 1}× (it is match ${match}).`
+        : 'Copied your message. Press ⌘F, then ⌘V: the thread scrolls to it.',
+    )
+  }
+  if (!place.messageId) return findIt()
+  try {
+    const result = await $.ui.scroll({ to: { requestId: place.messageId }, block: 'center' })
+    if (result?.deny) await findIt()
+  } catch {
+    await findIt()
+  }
+}
+
+// The desktop's Find in page, opened and filled from the clipboard by the keys a person would press: ⌘F, then ⌘V.
+// macOS only (osascript); false when it could not (no Accessibility permission, another system), so the caller
+// falls back to telling the person the two keys.
+async function findInApp($: EngineInterface, match: number) {
+  // ⌘G steps to the next match, as Enter would in the find bar, but never sends a message if the bar is not open.
+  const next = Array.from({ length: Math.min(Math.max(match - 1, 0), 20) }, () => ['-e', 'delay 0.15', '-e', 'tell application "System Events" to keystroke "g" using command down']).flat()
+  try {
+    const { exitCode } = await $.process.run(
+      ['osascript', '-e', 'tell application "System Events" to keystroke "f" using command down', '-e', 'delay 0.25', '-e', 'tell application "System Events" to keystroke "v" using command down', ...next],
+      { timeoutMs: 8_000 },
+    )
+    return exitCode === 0
+  } catch {
+    return false
+  }
 }
 
+// Where a row is the person's own message: typed in the terminal, sent from the desktop or through Remote Control.
+const PERSON = new Set<string | undefined>(['composer', 'sdk', 'bridge'])
+
 // The prompt hook exactly as `peer install` put it in Claude Code's settings, split into its arguments.
 async function promptHook($: EngineInterface): Promise<string[] | undefined> {
   const claude = (await $.env.get('CLAUDE_CONFIG_DIR')) || `${await $.env.get('HOME')}/.claude`
@@ -205,7 +366,8 @@ async function loadMemories($: EngineInterface) {
 
 // One row of the memory pane. New memories read as their sentence under a name; updates of one memory across
 // saves are one row, newest first, saying what was added last.
-type Entry = { id: string; title: string; when: string; lines: string[] }
+// messageId: the thread's row the memory came from, when it is known; the pane can scroll the thread to it.
+type Entry = { id: string; title: string; when: string; lines: string[]; messageId?: string; messageText?: string; messageMatch?: number }
 
 const titled = (name: string) => name.charAt(0).toUpperCase() + name.slice(1)
 const KIND: Record<string, string> = { preferences: 'your preference', profile: 'your profile' }
@@ -221,16 +383,16 @@ function sections(saves: { at: string; items: MemoryItem[] }[]) {
       const when = clock(save.at)
       // A memory that holds Claude Code's text is listed once, where it asks for a look.
       if (item.systemText) {
-        check.push({ id, title: titled(item.name), when, lines: item.lines })
+        check.push({ id, title: titled(item.name), when, lines: item.lines, messageId: item.messageId, messageText: item.messageText, messageMatch: item.messageMatch })
         return
       }
       if (item.change === 'updated') {
         const name = KIND[item.type] ? `${titled(KIND[item.type]!)}: ${item.name}` : titled(item.name)
         const known = updated.get(name)
         if (known) known.times += 1
-        else updated.set(name, { id, title: name, when, lines: item.lines, times: 1 })
+        else updated.set(name, { id, title: name, when, lines: item.lines, times: 1, messageId: item.messageId, messageText: item.messageText, messageMatch: item.messageMatch })
       } else {
-        const entry = { id, title: titled(item.name), when, lines: item.lines }
+        const entry = { id, title: titled(item.name), when, lines: item.lines, messageId: item.messageId, messageText: item.messageText, messageMatch: item.messageMatch }
         ;(item.change === 'removed' ? removed : added).push(entry)
       }
     })
@@ -239,6 +401,20 @@ function sections(saves: { at: string; items: MemoryItem[] }[]) {
   return { check, added, updated: merged, removed }
 }
 
+// /peer-thread and the band's Memory button open the same pane; says whether a surface seated it.
+async function openThread($: EngineInterface) {
+  await loadMemories($)
+  const opened = await $.ui.open({ id: MEMORY_PANE, title: 'This thread' })
+  return opened.isPlaced
+}
+
+// How many memories the thread holds, as the pane lists them: each new one, each updated one once, each to check;
+// removed ones are gone.
+function memoryCount(saves: { at: string; items: MemoryItem[] }[]) {
+  const groups = sections(saves)
+  return groups.check.length + groups.added.length + groups.updated.length
+}
+
 const clock = (at: string) => {
   const date = new Date(at)
   return Number.isNaN(date.getTime()) ? at : `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`
@@ -311,6 +487,8 @@ export const register: Register = on => {
     // Nothing under the prompt: clear the line an earlier version pinned there.
     $.ui.status(undefined)
     await refresh($).catch(() => {})
+    // A resumed thread, or one that loaded the mod later, has its Saved lines at once.
+    void loadMemories($).catch(() => {})
     return result
   })
 
@@ -323,35 +501,251 @@ export const register: Register = on => {
 
   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 looks again.
-    if (memoryOpen) await loadMemories($).catch(() => {})
+    // OpenViking saves a thread's memories when a turn ends past its threshold, so the open pane and the Saved lines
+    // under the thread's messages look again.
+    await loadMemories($).catch(() => {})
+    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) => {
+    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)]
+      if (items.length) {
+        const recall: Recall = { prompt: String(e.prompt ?? '').trim(), items }
+        await update($, recalls, was => [...(was ?? []), recall].slice(-RECALLS_KEPT))
+      }
+    } catch {}
+    return result
+  })
+
+  // Under the person's prompt, quiet lines: what was recalled for it, and what OpenViking saved from it. A press
+  // opens either list; nothing shows for a prompt that neither touched.
+  on('ui.render', { component: 'UserMessage' }, async ($, e, next) => {
+    // The person's own messages only: the terminal stamps them composer, the desktop (an SDK host) sdk, Remote
+    // Control bridge; notifications and other sessions' messages draw as they are.
+    if (!PERSON.has(e.props.origin?.kind)) return next(e)
+    const drawn = await next(e)
+    const text = String(e.props.text ?? '').trim()
+    const recall = [...((await read($, recalls)) ?? [])].reverse().find(r => r.prompt === text)
+    const thread = await read($, memories)
+    const saved = thread && 'saves' in thread ? thread.saves.flatMap(save => save.items.map(item => ({ ...item, at: save.at }))).filter(item => item.messageId === e.requestId) : []
+    if (drawn === undefined) return drawn
+    // What the transcript says came with this message: recalls a hook added, and the agent asking OpenViking. It
+    // covers messages from before the mod loaded; the live record covers a prompt the transcript has not caught up on.
+    const usedHere = thread && 'saves' in thread ? (thread.uses ?? []).filter(use => use.messageId === e.requestId) : []
+    const fromTranscript: RecallItem[] = usedHere
+      .filter(use => use.where === 'prompt')
+      .flatMap(use => use.items.map(title => ({ from: use.from === 'team' ? ('team' as const) : ('mine' as const), title, detail: use.from === 'team' ? "teammate's page" : 'your memory', uri: '' })))
+    const asked = usedHere.filter(use => use.where === 'tool')
+    if (!recall && !saved.length && !fromTranscript.length && !asked.length) return drawn
+    const { Box, Button, Markdown, Text } = $.ui.resolve(e)
+    const id = `memory-${e.requestId}`
+    const count = (n: number, one: string, many: string) => (n === 1 ? `1 ${one}` : `${n} ${many}`)
+    const isOpen = (await read($, openRecall)) === id
+
+    // What happened, said once: new memories by name; updates and recalls as counts.
+    const fromHere = saved.filter(item => item.exact)
+    const nearHere = saved.filter(item => !item.exact)
+    const recalled = fromTranscript.length ? fromTranscript : recall?.items ?? []
+    // The badge names the main thing (saved, else updated, else recalled); the words beside it name the rest.
+    const headline = fromHere.length ? 'Memory saved' : nearHere.length ? 'Memory updated' : recalled.length ? 'Memory recalled' : 'Memory asked'
+    const summary = [
+      fromHere.length && fromHere.map(item => item.name).join(', '),
+      nearHere.length && (fromHere.length ? `updated ${nearHere.length}` : nearHere.map(item => item.name).join(', ')),
+      recalled.length && (fromHere.length || nearHere.length ? `recalled ${recalled.length}` : count(recalled.length, 'memory', 'memories')),
+      asked.length && (fromHere.length || nearHere.length || recalled.length ? `asked ${asked.length}` : asked.map(use => use.kind).join(', ')),
+    ]
+      .filter(Boolean)
+      .join(' · ')
+
+    // A badge: on the terminal solid, elsewhere a soft tint of the memory color with the color as its text.
+    const pill = (word: string) =>
+      e.surface === 'terminal' ? (
+        <Text backgroundColor={SAVED_COLOR} color="#ffffff" bold size="caption">{` ${word} `}</Text>
+      ) : (
+        <Text backgroundColor={SOFT_BACKGROUND} color={SOFT_COLOR} bold size="caption">{` ${word} `}</Text>
+      )
+    // One memory as a card: its badge and name, the time right; the day and its kind under them; then its own
+    // text as written, headings, lists and code included.
+    const card = (key: string, word: string, title: RenderChildren, time: string, meta: string, body?: string) => (
+      <Box key={key} flexDirection="column" marginTop={1}>
+        <Box justifyContent="space-between" gap={1}>
+          <Box gap={1}>
+            {pill(word)}
+            {title}
+          </Box>
+          <Text dimColor tabular size="footnote">{time}</Text>
+        </Box>
+        <Text dimColor size="footnote">{meta}</Text>
+        {body ? <Markdown key={`${key}-body`} text={body} /> : null}
+      </Box>
+    )
+    const savedCard = (memory: MemoryItem & { at: string }, index: number) =>
+      card(
+        `s-${e.requestId}-${index}`,
+        memory.change === 'added' ? 'Saved' : memory.change === 'removed' ? 'Forgotten' : 'Updated',
+        <Text bold wrap="truncate-end">{titled(memory.name)}</Text>,
+        clock(memory.at),
+        [fullDay(memory.at), KIND_WORD[memory.type] ?? memory.type, memory.exact ? '' : 'near this message'].filter(Boolean).join(' · '),
+        memory.body || memory.lines.join('\n'),
+      )
+    // A recalled memory's name is its button (a button holds text only): a press copies its address.
+    const recallCard = (memory: RecallItem, index: number) =>
+      card(
+        `r-${e.requestId}-${index}`,
+        'Recalled',
+        <Button
+          key={`r-${e.requestId}-${index}`}
+          plain
+          onPress={press => {
+            if (!memory.uri) return
+            void $.ui.copy({ text: memory.uri, surface: press.surface })
+            $.ui.toast('Copied its address')
+          }}
+        >
+          <Text bold wrap="truncate-end">{memory.title}</Text>
+        </Button>,
+        '',
+        `${memory.from === 'team' ? 'From a teammate' : 'From your memory'} · ${memory.detail}`,
+      )
+
+    return (
+      <Box flexDirection="column">
+        {drawn}
+        {/* The one accent: the badge, beside the button, as a surface draws a button's own text plainly. */}
+        <Box gap={1}>
+          {pill(headline)}
+          <Button key={id} plain onPress={() => void update($, openRecall, was => (was === id ? null : id))}>
+            <Text dimColor size="footnote" wrap="truncate-end">{`${summary} ${isOpen ? '▾' : '▸'}`}</Text>
+          </Button>
+        </Box>
+        {isOpen && (
+          <Box flexDirection="column" paddingLeft={2} marginBottom={1}>
+            {fromHere.map(savedCard)}
+            {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}`),
+            )}
+          </Box>
+        )}
+      </Box>
+    )
+  })
+
   on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
     if (!looked) {
       looked = true
       await refresh($).catch(() => {})
     }
     const now = await read($, shared)
-    if (e.props.hasSurvey || now === null) return next(e)
+    // The band leads with this thread's memory: its count in a square, a press away from the /peer-thread pane. It
+    // shows once the memory answers or the thread was shared here; the workspace goes unnamed (the thread is in one),
+    // and the one control changes in place, stop to start and back.
+    const saved = await read($, memories)
+    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)
-    // One band in both states: the label's own surface says the state (accent when shared, gray when not),
-    // and the one control changes in place, stop to start and back.
+    // 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>
-        <Text backgroundColor={now.isShared ? 'suggestion' : 'inactive'} color="inverseText" bold>
-          {' Peer '}
-        </Text>
-        <Text bold={now.isShared} dimColor={!now.isShared}>{now.workspace ? ` ${now.workspace}  ` : '  '}</Text>
-        <Button
-          key="toggle"
-          label={now.isShared ? '/peer stop' : '/peer start'}
-          plain
-          dimColor
-          onPress={() => send($, now.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>
     )
   })
@@ -368,10 +762,9 @@ export const register: Register = on => {
   })
 
   on('command.run', { command: 'peer-thread' }, async ($, e, next) => {
-    await loadMemories($)
-    const opened = await $.ui.open({ id: MEMORY_PANE, title: 'This thread' })
-    memoryOpen = opened.isPlaced
-    return { text: opened.isPlaced ? "Peer: this thread's memories are in the pane." : 'Peer: no room for a pane here; `peer thread <session id>` prints the same list.' }
+    const placed = await openThread($)
+    memoryOpen = placed
+    return { text: placed ? "Peer: this thread's memories are in the pane." : 'Peer: no room for a pane here; `peer thread <session id>` prints the same list.' }
   })
 
   // /peer-all opens the search pane on the words typed after it; without room for a pane, the hook answers.
@@ -639,16 +1032,29 @@ export const register: Register = on => {
               <Text dimColor wrap="wrap">
                 {entry.lines.join(' ') || '(no text)'}
               </Text>
-              <Button
-                key={`${id}-copy`}
-                label="Copy"
-                plain
-                dimColor
-                onPress={press => {
-                  void $.ui.copy({ text: [entry.title, ...entry.lines].join('\n'), surface: press.surface })
-                  $.ui.toast('Copied')
-                }}
-              />
+              <Box gap={2}>
+                {entry.messageId && (
+                  // The thread scrolls to the message the memory came from, where the surface lets a plugin scroll
+                  // it (the terminal). The desktop does not: there the message's words go to the clipboard, and
+                  // the app's own Find in page (⌘F) scrolls to them.
+                  <Button
+                    key={`${id}-show`}
+                    label="Show in thread"
+                    plain
+                    onPress={press => void showInThread($, entry, press.surface)}
+                  />
+                )}
+                <Button
+                  key={`${id}-copy`}
+                  label="Copy"
+                  plain
+                  dimColor
+                  onPress={press => {
+                    void $.ui.copy({ text: [entry.title, ...entry.lines].join('\n'), surface: press.surface })
+                    $.ui.toast('Copied')
+                  }}
+                />
+              </Box>
             </Box>
           )}
         </Box>
@@ -665,6 +1071,39 @@ export const register: Register = on => {
         </Box>
       )
 
+    // 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 useRow = (use: MemoryUse, index: number) => {
+      const id = `use-${index}`
+      const isOpen = open === id
+      const n = use.items.length
+      const amount =
+        use.from === 'team'
+          ? n === 1 ? "1 teammate's page" : `${n} teammates' pages`
+          : use.kind === 'listed' ? `${n === 1 ? '1 memory' : `${n} memories`} listed` : `${n} recalled`
+      const what = use.where === 'tool' ? `${USE_WORDS.tool}: ${use.kind}` : `${USE_WORDS[use.where] ?? use.where} · ${amount}`
+      return (
+        <Box key={id} flexDirection="column">
+          <Box justifyContent="space-between" gap={1}>
+            <Button key={id} plain onPress={() => void update($, openMemory, was => (was === id ? null : id))}>
+              <Text bold={isOpen} wrap="truncate-end">{what}</Text>
+            </Button>
+            <Text dimColor tabular size="footnote">{clock(use.at)}</Text>
+          </Box>
+          {isOpen && (
+            <Box flexDirection="column" paddingLeft={2} marginBottom={1}>
+              {use.items.map((item, i) => (
+                <Text key={`${id}-${i}`} dimColor size="footnote" wrap="truncate-end">{`· ${item}`}</Text>
+              ))}
+              {use.messageId && <Button key={`${id}-show`} label="Show in thread" plain onPress={press => void showInThread($, use, press.surface)} />}
+            </Box>
+          )}
+        </Box>
+      )
+    }
+
     return (
       <Box flexDirection="column">
         <Box justifyContent="space-between" gap={1}>
@@ -674,6 +1113,15 @@ export const register: Register = on => {
             {reload}
           </Box>
         </Box>
+        {uses.length > 0 && (
+          <Box flexDirection="column" marginTop={1}>
+            <Box justifyContent="space-between">
+              <Text dimColor size="caption">Used</Text>
+              <Text dimColor tabular size="caption">{String(uses.length)}</Text>
+            </Box>
+            {uses.map(useRow)}
+          </Box>
+        )}
         {total === 0 && <Text dimColor>Nothing saved yet. OpenViking saves after longer turns.</Text>}
         {section('Check', groups.check, true)}
         {section('New', groups.added)}