@webinson/peer 0.4.2 → 0.4.14

package/bin/peer.mjs

@@ -34,11 +34,15 @@ const HELP = `peer: share chosen agent threads with your team
                     sign in once and set up Claude Code (/peer, /peer stop, /peer-list)
   peer list         people in the workspace, their shared threads and what they work on
   peer status       who you are, the workspace and the threads this computer shares
-  peer doctor       why /peer reaches the model instead of Peer's hook
+  peer doctor       why Peer's hook did not answer /peer
   peer team connect <url> --as <member> [--project <id>]
                     connect to the team's memory server (your key on stdin); new threads in the
-                    project's repositories then start with teammates' published findings
+                    project's repositories then start with teammates' published findings. The
+                    project is the Hub project holding this repository, else the repository itself
   peer team status  the team server, project and the last recalls
+  peer all [words] [here] [--newest | --oldest] [page N]
+                    your own memories in your personal OpenViking, or the ones with these words
+                    (full text); here: only this repository's. /peer-all in Claude Code
   peer install      set up Claude Code again (hooks, the two commands and the thread mark)
   peer uninstall    remove them from Claude Code
   peer logout       forget the sign-in on this computer
@@ -242,6 +246,11 @@ async function hook(event) {
     const prompt = String(input.prompt ?? "").trim();
     const command = /^\/peer(?:\s+([\s\S]*))?$/.exec(prompt);
     const argument = command?.[1]?.trim() ?? "";
+    const all = /^\/peer-all(?:\s+([\s\S]*))?$/.exec(prompt);
+    if (all) {
+      const query = memoryQuery((all[1] ?? "").split(/\s+/).filter(Boolean), input.cwd || process.cwd());
+      return block(await memoryText(query).catch((error) => `Peer: your memories did not load (${error.message})`));
+    }
     if (prompt === "/peer-list") {
       let saved;
       try {
@@ -273,9 +282,11 @@ async function hook(event) {
       await report(saved, session, argument ? "working" : "idle", input.cwd).catch((error) => (hubError = error));
       const said = hubError ? `Peer: shared, but the hub did not answer yet (${hubError.message}). The next turn tries again.` : sharedText;
       const sessionTitle = retitle(input, true, what);
-      if (!argument) return block(said, sessionTitle);
-      log("answered /peer with a message: shared, message passed on");
-      return answer({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: `${SHARED_NOTE}\n${said}`, ...(sessionTitle ? { sessionTitle } : {}) } });
+      // A bare /peer reaches the agent too, which confirms in one line: a block would show the person Claude
+      // Code's "hook blocked your prompt" warning for what went right.
+      const note = argument ? said : `${said}\n${ALONE_NOTE}`;
+      log(argument ? "answered /peer with a message: shared, message passed on" : "answered /peer: shared, the agent confirms");
+      return answer({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: `${SHARED_NOTE}\n${note}`, ...(sessionTitle ? { sessionTitle } : {}) } });
     }
     if (shared) await reportQuietly(session, "working", input.cwd);
     // Claude Code may name a thread after its first prompts; the mark goes back on, or comes off a thread
@@ -322,6 +333,10 @@ const COMMANDS = path.join(CLAUDE, "commands");
 
 // The hook's note to the model when `/peer <message>` shares a thread; peer.md looks for it.
 const SHARED_NOTE = "[Peer's hook ran]";
+// Added when /peer came alone: there is no message to work on, only the confirmation, and its privacy line
+// is a promise the person relies on, so it stays whole.
+const ALONE_NOTE =
+  "The person typed /peer alone. Reply with only that confirmation, in one or two short lines in the person's language: where the thread is shared, that teammates see its repository, branch and state but never the conversation, and that /peer stop ends it. Do nothing else and use no tools.";
 
 const COMMAND_FILES = {
   "peer.md": `---
@@ -340,6 +355,14 @@ description: List the people in your Peer workspace and the agent threads they s
 Peer's hook answers this command before it reaches you, so you should not be reading it. If you are,
 the hook did not run or did not answer in time: tell the person to run \`peer doctor\` in a terminal, which says why.
 Do nothing else.
+`,
+  "peer-all.md": `---
+description: List and search what your own OpenViking memory holds (/peer-all [words] [here] [page N])
+argument-hint: "[words] [here] [page N]"
+---
+Peer's hook answers this command before it reaches you, so you should not be reading it. If you are,
+the hook did not run or did not answer in time: tell the person to run \`peer doctor\` in a terminal, which says why.
+Do nothing else.
 `,
 };
 
@@ -377,7 +400,7 @@ function install() {
   writeJson(SETTINGS, settings, 0o644);
   fs.mkdirSync(COMMANDS, { recursive: true });
   for (const [name, text] of Object.entries(COMMAND_FILES)) fs.writeFileSync(path.join(COMMANDS, name), text);
-  console.log(`Claude Code: hooks in ${SETTINGS}, /peer and /peer-list in ${COMMANDS}. Sessions started from now on have them.`);
+  console.log(`Claude Code: hooks in ${SETTINGS}, /peer, /peer-list and /peer-all in ${COMMANDS}. Sessions started from now on have them.`);
   installMark();
 }
 
@@ -488,7 +511,7 @@ function status() {
   console.log(shared.length ? `Threads shared from this computer: ${shared.join(", ")}` : "No thread shared from this computer.");
 }
 
-// ---- peer doctor: why /peer reaches the model instead of the hook ----
+// ---- peer doctor: why Peer's hook did not answer /peer ----
 
 async function doctor() {
   let problems = 0;
@@ -545,7 +568,7 @@ async function doctor() {
   }
   if (process.env.CLAUDE_CONFIG_DIR) console.log(`  note  CLAUDE_CONFIG_DIR=${process.env.CLAUDE_CONFIG_DIR}: Claude Code must run with the same value`);
   const commands = Object.keys(COMMAND_FILES).filter((name) => fs.existsSync(path.join(COMMANDS, name)));
-  if (commands.length === Object.keys(COMMAND_FILES).length) ok(`/peer and /peer-list in ${COMMANDS}`);
+  if (commands.length === Object.keys(COMMAND_FILES).length) ok(`/peer, /peer-list and /peer-all in ${COMMANDS}`);
   else bad(`commands missing in ${COMMANDS}: run \`peer install\``);
 
   // The hook Claude Code would run, run here: a /peer-list must come back answered within Claude's limit.
@@ -571,11 +594,287 @@ async function doctor() {
   console.log(
     problems
       ? `\n${problems} thing(s) to fix. Then start a new Claude Code session.`
-      : "\nPeer is set up here. If /peer still reaches the model, Claude Code is not loading your user settings: an app or IDE that runs Claude through the Agent SDK may ignore ~/.claude/settings.json. Start `claude` in a terminal and try /peer there.",
+      : "\nPeer is set up here. If the agent still says the hook did not run, Claude Code is not loading your user settings: an app or IDE that runs Claude through the Agent SDK may ignore ~/.claude/settings.json. Start `claude` in a terminal and try /peer there.",
   );
   if (problems) process.exitCode = 1;
 }
 
+// ---- this thread's memories: what the person's own OpenViking kept from a Claude Code thread ----
+// The OpenViking plugin stores each Claude Code thread as session `cc-<session id>`; every commit leaves a
+// memory_diff.json with what it added, updated or removed. `peer thread` reads those and says them in sentences,
+// with no model call. Read-only: it never changes a memory.
+
+const OV_CONF = process.env.PEER_OV_CONF || path.join(os.homedir(), ".openviking", "ovcli.conf");
+
+async function ovRead(ov, route) {
+  const response = await fetch(`${ov.url}/api/v1${route}`, {
+    headers: { "x-api-key": ov.api_key ?? "", "x-openviking-account": ov.account ?? "default", "x-openviking-user": ov.user ?? "" },
+    signal: AbortSignal.timeout(5000),
+  });
+  const value = await response.json().catch(() => ({}));
+  if (!response.ok || value.status !== "ok") throw new Error(value.error?.message ?? `OpenViking answered ${response.status}`);
+  return value.result;
+}
+
+// The memory's name in words: `entities/software_system/peer.md` is "peer", `.../autonomous_auditing.md` "autonomous auditing".
+const memoryName = (uri) => path.basename(String(uri), ".md").replace(/[_-]+/g, " ");
+
+// The sentence a memory starts with: OpenViking writes it under `# Summary`; otherwise its first line of text.
+function summaryOf(text) {
+  const lines = String(text ?? "").split("\n").map((line) => line.trim());
+  const at = lines.indexOf("# Summary");
+  const first = (at >= 0 ? lines.slice(at + 1) : lines).find((line) => line && !line.startsWith("#"));
+  return (first ?? "").replace(/^[-*]\s+/, "");
+}
+
+// What an update added: the lines in `after` that `before` did not have.
+function addedLines(before, after) {
+  const had = new Set(String(before ?? "").split("\n").map((line) => line.trim()));
+  return String(after ?? "").split("\n").map((line) => line.trim()).filter((line) => line && !had.has(line) && !line.startsWith("#")).map((line) => line.replace(/^[-*]\s+/, ""));
+}
+
+// A memory's own text as Markdown, for a card that shows it: without the conversation OpenViking quotes under it
+// (`# … ChatLog:`), without its `# Summary` heading and without a first heading that only repeats its name.
+function memoryBody(text, name) {
+  const lines = String(text ?? "").split("\n");
+  const cut = lines.findIndex((line) => /^#+ .*ChatLog/i.test(line.trim()));
+  const kept = (cut >= 0 ? lines.slice(0, cut) : lines).filter((line) => line.trim() !== "# Summary");
+  if (kept[0] && /^# /.test(kept[0]) && kept[0].slice(2).trim().toLowerCase().replace(/[_-]+/g, " ") === String(name).toLowerCase()) kept.shift();
+  return kept.join("\n").replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, "").trim().slice(0, 3000);
+}
+
+// Text Claude Code wrote into the turn, not the person: kept by the extraction, flagged so the person sees it.
+const hasSystemText = (text) => /This is how Claude Code surfaces messages|<system-reminder>/.test(String(text ?? ""));
+
+// The thread's own messages as Claude Code keeps them (~/.claude/projects/<project>/<session>.jsonl): the person's
+// prompts with the id their row in the thread has, and when they were sent.
+// What a find in the thread meets, in order: the person's own messages and the agent's written replies, with the
+// Markdown marks a view does not draw taken out, cased alike.
+// Curly quotes count as straight ones and accents as their letters (pamat finds pamäť), as the desktop's find treats them.
+const visible = (text) =>
+  String(text ?? "")
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .replace(/[\u2018\u2019\u201b\u2032]/g, "'")
+    .replace(/[\u201c\u201d\u201f\u2033]/g, '"')
+    .replace(/[*`#>_~]/g, "")
+    .replace(/\s+/g, " ")
+    .toLowerCase();
+
+function transcriptPrompts(session) {
+  const projects = path.join(CLAUDE, "projects");
+  let file;
+  try {
+    file = fs.readdirSync(projects).map((dir) => path.join(projects, dir, `${session}.jsonl`)).find((f) => fs.existsSync(f));
+  } catch {}
+  if (!file) return [];
+  const prompts = [];
+  const shown = [];
+  for (const line of fs.readFileSync(file, "utf8").split("\n")) {
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    // The person's own messages only: not what a skill or a command put in the thread (isMeta), not a command's row.
+    // The agent's replies and the one-line descriptions of its steps are drawn too, and a find meets them.
+    if (row.type === "assistant" && Array.isArray(row.message?.content)) {
+      for (const block of row.message.content) {
+        if (block?.type === "text" && block.text) shown.push(visible(block.text));
+        else if (block?.type === "tool_use" && typeof block.input?.description === "string") shown.push(visible(block.input.description));
+      }
+      continue;
+    }
+    // A command's output (`system`, local_command) is drawn in the thread as well.
+    if (row.type === "system" && typeof row.content === "string") {
+      shown.push(visible(row.content.replace(/<[^>]+>/g, " ")));
+      continue;
+    }
+    if (row.type !== "user" || !row.uuid) continue;
+    const content = row.message?.content;
+    const text = typeof content === "string" ? content : Array.isArray(content) ? content.filter((b) => b?.type === "text").map((b) => b.text).join("\n") : "";
+    // A command's row and its output show in the thread, so they count for a find, but they are not messages.
+    if (row.isMeta || /^\s*<(command-name|local-command)/.test(text)) {
+      if (!row.isMeta || /^\s*<local-command-stdout/.test(text)) shown.push(visible(text.replace(/<[^>]+>/g, " ")));
+      continue;
+    }
+    if (!text) continue;
+    // Pasted text shows as an attachment, so the words a find can meet are the person's own beside it.
+    const own = text.replace(/<pasted_content[^>]*>[\s\S]*?<\/pasted_content[^>]*>/g, "").trim();
+    const keys = [...new Set([promptKey(text), promptKey(own)])].filter(Boolean);
+    if (own) {
+      prompts.push({ id: row.uuid, at: Date.parse(row.timestamp ?? "") || 0, keys, own, shownAt: shown.length });
+      shown.push(visible(own));
+    }
+  }
+  // Each message's find: one of its own lines whole, the one the thread holds the fewest times (the longest of
+  // those), and which match, in the thread's order, is this message. A line, as a find does not match across lines.
+  const count = (needle, upTo = shown.length) => shown.slice(0, upTo).reduce((n, text) => n + text.split(needle).length - 1, 0);
+  for (const prompt of prompts) {
+    const lines = prompt.own.split("\n").map((line) => line.trim().replace(/\s+/g, " ")).filter((line) => visible(line).length >= 3);
+    let best;
+    for (const line of lines) {
+      const times = count(visible(line));
+      if (!best || times < best.times || (times === best.times && line.length > best.line.length)) best = { line, times };
+    }
+    const text = (best?.line ?? findPhrase(prompt.own)).slice(0, 500);
+    prompt.find = { text, match: count(visible(text), prompt.shownAt) + 1 };
+  }
+  return prompts;
+}
+
+// The words a find looks for: the message's first line, at most 60 characters, cut where a word ends.
+function findPhrase(text) {
+  const line = String(text).trim().split("\n")[0].replace(/\s+/g, " ");
+  if (line.length <= 60) return line;
+  const cut = line.slice(0, 60);
+  return cut.slice(0, cut.lastIndexOf(" ") > 30 ? cut.lastIndexOf(" ") : 60);
+}
+
+// One message's text as both sides can match it: its first line, spaces collapsed, cased alike, cut short.
+const promptKey = (text) => String(text ?? "").trim().split("\n")[0].replace(/\s+/g, " ").toLowerCase().slice(0, 80);
+
+// The person's messages a save was made from, in order: OpenViking's copy carries its own ids and the time it was
+// captured, a little after the message was sent.
+async function savedPrompts(ov, archive) {
+  try {
+    const text = await ovRead(ov, `/content/read?uri=${encodeURIComponent(`${archive}/messages.jsonl`)}`);
+    return String(typeof text === "string" ? text : text?.content ?? "")
+      .split("\n")
+      .map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      })
+      .filter((row) => row?.role === "user")
+      .map((row) => ({ key: promptKey((row.parts ?? []).filter((part) => part.type === "text").map((part) => part.text).join("\n")), at: Date.parse(row.created_at ?? "") || 0 }))
+      .filter((row) => row.key && !row.key.startsWith("<"));
+  } catch {
+    return [];
+  }
+}
+
+// The thread's row for a message OpenViking captured: the latest prompt with the same text sent before the capture.
+function rowFor(prompts, key, capturedAt) {
+  let found;
+  for (const prompt of prompts) if (prompt.keys.includes(key) && (!capturedAt || prompt.at <= capturedAt + 5000)) found = prompt;
+  return found;
+}
+
+// A new memory quotes the message it came from in its ChatLog: `**user [peer=…]**: <the message>`.
+const quotedPrompt = (after) => promptKey(/\*\*user[^*]*\*\*:\s*(.+)/.exec(String(after ?? ""))?.[1] ?? "");
+
+// Where memory went into the thread, as the transcript keeps it: what a hook added at the session's start or with
+// a prompt (OpenViking's <openviking-context>, Peer's <teammates-project-knowledge>), and the agent's own calls of
+// OpenViking's tools. Each under the person's message it came with, where there is one.
+function threadUses(session, prompts) {
+  const projects = path.join(CLAUDE, "projects");
+  let file;
+  try {
+    file = fs.readdirSync(projects).map((dir) => path.join(projects, dir, `${session}.jsonl`)).find((f) => fs.existsSync(f));
+  } catch {}
+  if (!file) return [];
+  const byId = new Map(prompts.map((prompt) => [prompt.id, prompt]));
+  const name = (text) => path.basename(String(text).trim(), ".md").replace(/[_-]+/g, " ");
+  const clean = (text) => plain(String(text).replace(/\*\*/g, "").replace(/`/g, "")).slice(0, 120);
+  const uses = [];
+  let last;
+  for (const line of fs.readFileSync(file, "utf8").split("\n")) {
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (byId.has(row.uuid)) last = byId.get(row.uuid);
+    const at = row.timestamp ?? "";
+    const near = (where) => (where === "start" || where === "resume" || !last ? {} : { messageId: last.id, messageText: last.find?.text, messageMatch: last.find?.match });
+    const attachment = row.attachment;
+    if (row.type === "attachment" && attachment?.type === "hook_additional_context") {
+      const text = (attachment.content ?? []).join("\n");
+      const event = String(attachment.hookEvent ?? attachment.hookName ?? "");
+      for (const block of text.matchAll(/<openviking-context([^>]*)>([\s\S]*?)<\/openviking-context>/g)) {
+        const source = /source="(\w+)"/.exec(block[1])?.[1];
+        const where = event.startsWith("SessionStart") ? (source === "resume" ? "resume" : "start") : "prompt";
+        const listed = [...block[2].matchAll(/^\s+- (.+\.md)\s*$/gm)].map((m) => name(m[1]));
+        const recalled = [...block[2].matchAll(/^- \[\S+ \d+%\] (.+)$/gm)].map((m) => (m[1].startsWith("viking://") ? name(m[1]) : clean(m[1])));
+        const items = recalled.length ? recalled : listed;
+        if (items.length) uses.push({ at, where, from: "yours", kind: recalled.length ? "recalled" : "listed", items, ...near(where) });
+      }
+      for (const block of text.matchAll(/<teammates-project-knowledge[^>]*>([\s\S]*?)<\/teammates-project-knowledge>/g)) {
+        const items = [...block[1].matchAll(/^- \[[^\]]+\] (.+)$/gm)].map((m) => clean(m[1]));
+        const where = event.startsWith("SessionStart") ? "start" : "prompt";
+        if (items.length) uses.push({ at, where, from: "team", kind: "recalled", items, ...near(where) });
+      }
+    }
+    // The agent asking OpenViking itself, through its MCP tools (search, find, read, ...).
+    if (row.type === "assistant" && Array.isArray(row.message?.content)) {
+      for (const block of row.message.content) {
+        if (block?.type !== "tool_use" || !/openviking/i.test(String(block.name))) continue;
+        const input = block.input ?? {};
+        const detail = input.query ?? input.pattern ?? input.uri ?? (Array.isArray(input.uris) ? input.uris.join(", ") : "") ?? "";
+        uses.push({ at, where: "tool", from: "yours", kind: String(block.name).split("__").pop(), items: detail ? [clean(String(detail).startsWith("viking://") ? name(detail) : detail)] : [], ...near("tool") });
+      }
+    }
+  }
+  return uses.slice(-200);
+}
+
+async function threadMemories(session) {
+  const ov = readJson(OV_CONF);
+  if (!ov?.url) return { connected: false, reason: `no OpenViking client config at ${OV_CONF}` };
+  const base = `viking://user/${ov.user}/sessions/cc-${session}`;
+  let archives;
+  try {
+    archives = await ovRead(ov, `/fs/ls?uri=${encodeURIComponent(`${base}/history`)}`);
+  } catch (error) {
+    if (/not found|no such|404/i.test(error.message)) return { connected: true, saves: [], uses: threadUses(session, transcriptPrompts(session)) };
+    throw error;
+  }
+  const saves = [];
+  const prompts = transcriptPrompts(session);
+  for (const archive of archives.filter((entry) => entry.isDir)) {
+    let diff;
+    try {
+      diff = JSON.parse(await ovRead(ov, `/content/read?uri=${encodeURIComponent(`${archive.uri}/memory_diff.json`)}`));
+    } catch {
+      continue;
+    }
+    const ops = diff.operations ?? {};
+    // Which row in the thread each memory belongs to: a new one under the message it quotes (exact); an update or
+    // a removal, which quotes nothing, under the save's last message (only near it).
+    const captured = prompts.length ? await savedPrompts(ov, archive.uri) : [];
+    // An update goes under the save's last message that is the person's own (a skill's or command's text is not).
+    let nearRow;
+    for (const row of [...captured].reverse()) if ((nearRow = rowFor(prompts, row.key, row.at))) break;
+    const quotedRow = (after) => {
+      const key = quotedPrompt(after);
+      const copy = [...captured].reverse().find((row) => row.key === key);
+      return key ? rowFor(prompts, key, copy?.at) : undefined;
+    };
+    // The row's id, and its words as typed: where a surface cannot scroll to the row, its find can look for them.
+    const placed = (row, exact) =>
+      row ? { messageId: row.id, messageText: row.find.text, messageMatch: row.find.match, exact } : nearRow ? { messageId: nearRow.id, messageText: nearRow.find.text, messageMatch: nearRow.find.match, exact: false } : {};
+    const items = [
+      ...(ops.adds ?? []).map((op) => ({ change: "added", type: op.memory_type, name: memoryName(op.uri), lines: [summaryOf(op.after)], systemText: hasSystemText(op.after), ...placed(quotedRow(op.after), true) })),
+      ...(ops.updates ?? []).map((op) => ({ change: "updated", type: op.memory_type, name: memoryName(op.uri), lines: addedLines(op.before, op.after), systemText: hasSystemText(op.after) && !hasSystemText(op.before), ...placed(undefined, false) })),
+      ...(ops.deletes ?? []).map((op) => ({ change: "removed", type: op.memory_type, name: memoryName(op.uri), lines: [summaryOf(op.before)], systemText: false, ...placed(undefined, false) })),
+    ].map((item) => ({ ...item, name: plain(item.name), lines: item.lines.filter(Boolean).slice(0, 3).map((line) => String(line).replace(/[\u0000-\u001f\u007f-\u009f]/g, "").slice(0, 300)) }));
+    // Each memory's text for a card: a new or removed one whole, an update as the lines it added.
+    const bodies = [
+      ...(ops.adds ?? []).map((op) => memoryBody(op.after, memoryName(op.uri))),
+      ...(ops.updates ?? []).map((op) => addedLines(op.before, op.after).slice(0, 12).map((line) => `- ${line}`).join("\n")),
+      ...(ops.deletes ?? []).map((op) => memoryBody(op.before, memoryName(op.uri))),
+    ];
+    items.forEach((item, index) => (item.body = String(bodies[index] ?? "").slice(0, 3000)));
+    saves.push({ at: diff.extracted_at ?? archive.modTime, items });
+  }
+  return { connected: true, saves: saves.sort((a, b) => String(b.at).localeCompare(String(a.at))), uses: threadUses(session, prompts) };
+}
+
 // ---- team memory: teammates' published project knowledge at the start of a thread ----
 // The team's OpenViking server holds pages members published for a project. `peer team connect` saves this
 // member's address and key; the hooks then add the best few teammates' pages to the first prompt of a thread
@@ -587,7 +886,10 @@ const TEAM_LOG = path.join(HOME, "team-memory", "recall.log");
 
 // OpenViking names a repository by its normalized origin URL; the team scripts do the same.
 function repositoryPeer(cwd) {
-  const remote = git(cwd, "remote", "get-url", "origin");
+  return repositoryKey(git(cwd, "remote", "get-url", "origin"));
+}
+
+function repositoryKey(remote) {
   if (!remote) return "";
   return remote
     .replace(/^[a-z+]+:\/\//i, "")
@@ -610,9 +912,19 @@ async function teamCall(team, method, route, body, timeoutMs = 3000) {
   return { status: response.status, value: await response.json().catch(() => ({})) };
 }
 
+// The project is the Hub's: the workspace project whose repositories include this one, with all of its
+// repositories. A repository in no Hub project (or without a sign-in) is a project of its own, named by its key.
+async function teamProject(repo) {
+  const saved = config();
+  if (!saved?.session || !saved?.workspace) return { project: repo, repos: [repo] };
+  const manifest = await call(saved, "GET", `/workspaces/${saved.workspace}/manifest`, undefined, 10000);
+  const keysOf = (project) => (project.repositories ?? []).map((r) => repositoryKey(r.url ?? "")).filter(Boolean);
+  const found = (manifest?.projects ?? []).find((project) => keysOf(project).includes(repo));
+  return found ? { project: found.id, repos: keysOf(found) } : { project: repo, repos: [repo] };
+}
+
 async function teamConnect(args) {
   const member = option(args, "--as");
-  const project = option(args, "--project") ?? "alpha";
   const repo = option(args, "--repo") ?? repositoryPeer(process.cwd());
   const url = (args[0] || "").replace(/\/+$/, "");
   if (!url || !member) throw new Error("usage: peer team connect <server-url> --as <member> [--project <id>] [--repo <id>], key on stdin");
@@ -622,11 +934,14 @@ async function teamConnect(args) {
   for await (const chunk of process.stdin) chunks.push(chunk);
   const key = Buffer.concat(chunks).toString("utf8").trim();
   if (!key) throw new Error("no key on stdin: printf '%s' \"$KEY\" | peer team connect …");
+  const given = option(args, "--project");
+  const found = given ? { project: given, repos: [repo] } : await teamProject(repo);
+  const { project } = found;
   const team = { url, member, key };
   const { status } = await teamCall(team, "POST", "/search/find", { query: "probe", target_uri: `viking://resources/projects/${project}`, limit: 1 }, 10000);
   if (status >= 300) throw new Error(`the team server refused ${member}'s key for project ${project} (${status})`);
   const saved = readJson(TEAM_FILE) ?? {};
-  const repos = saved.project === project ? [...new Set([...(saved.repos ?? []), repo])] : [repo];
+  const repos = [...new Set([...(saved.project === project ? saved.repos ?? [] : []), ...found.repos, repo])];
   writeJson(TEAM_FILE, { url, member, project, repos, key });
   console.log(`Team memory: ${member} on ${url}, project ${project}, repositories ${repos.join(", ")}.`);
   if (readJson(SETTINGS)) install();
@@ -721,6 +1036,159 @@ async function teamHook(event) {
   answer({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: block } });
 }
 
+// ---- your own memory: what your personal OpenViking remembered, listed and searched ----
+// Reads the person's own OpenViking server as its CLI is configured (~/.openviking/ovcli.conf). `/peer-all` is
+// answered by the hook, so the list is shown to the person and never enters the thread (nor its capture).
+
+const MEMORY_CONF = process.env.PEER_OPENVIKING_CONF || path.join(os.homedir(), ".openviking", "ovcli.conf");
+const MEMORY_PAGE = 20;
+
+function memoryServer() {
+  const conf = readJson(MEMORY_CONF);
+  if (!conf?.url || !conf?.user) throw new Error(`no personal OpenViking configured (${MEMORY_CONF})`);
+  return conf;
+}
+
+async function memoryCall(conf, route, body) {
+  const response = await fetch(`${conf.url.replace(/\/+$/, "")}/api/v1${route}`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...(conf.api_key ? { "x-api-key": conf.api_key } : {}),
+      "x-openviking-account": conf.account || "default",
+      "x-openviking-user": conf.user,
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(8000),
+  });
+  const value = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(`${route}: ${response.status} ${plain(value?.error?.message ?? value?.detail ?? "")}`);
+  return value.result ?? {};
+}
+
+// viking://user/<u>/peers/<repo>/memories/<type>/… or viking://user/<u>/memories/<type>/… (global).
+function memoryWhere(uri) {
+  const match = /^viking:\/\/user\/[^/]+\/(?:peers\/([^/]+)\/)?memories\/([^/]+)\/(.+)$/.exec(uri);
+  if (!match) return null;
+  const [, repo, type, rest] = match;
+  const title = rest.split("/").pop().replace(/\.md$/, "").replace(/[_-]+/g, " ");
+  return { repo: repo || "global", type, title };
+}
+
+const isMemoryFile = (uri) => uri.endsWith(".md") && !uri.split("/").pop().startsWith(".") && memoryWhere(uri);
+
+// `peer all [text] [page N] [--here] [--newest | --oldest]`; the same words after /peer-all. Without a sort the
+// memories come in OpenViking's own order.
+function memoryQuery(words, cwd) {
+  const query = { text: [], page: 1, here: false, sort: "" };
+  for (let i = 0; i < words.length; i++) {
+    if (words[i] === "--here" || words[i] === "here") query.here = true;
+    else if (words[i] === "--newest" || words[i] === "--oldest") query.sort = words[i] === "--newest" ? "new" : "old";
+    else if ((words[i] === "page" || words[i] === "--page") && /^\d+$/.test(words[i + 1] ?? "")) query.page = Math.max(1, Number(words[++i]));
+    else query.text.push(words[i]);
+  }
+  query.text = query.text.join(" ").trim();
+  query.repo = query.here ? repositoryPeer(cwd) : "";
+  return query;
+}
+
+// Diacritics do not count: a letter matches its accented forms, so `pamat` finds "pamäť" and `pamäť` finds "pamat".
+const LETTERS = { a: "aáäàâ", c: "cčç", d: "dď", e: "eéěëèê", i: "iíìî", l: "lĺľ", n: "nňñ", o: "oóôöò", r: "rŕř", s: "sš", t: "tť", u: "uúůüù", y: "yý", z: "zž" };
+
+// The words of a search as OpenViking grep patterns: each word, or each "quoted phrase" as one, at most six.
+function memoryTerms(text) {
+  const words = [...text.matchAll(/"([^"]+)"|(\S+)/g)].map((m) => (m[1] ?? m[2]).trim()).filter(Boolean).slice(0, 6);
+  return words.map((word) =>
+    [...word.toLowerCase()]
+      .map((char) => {
+        const base = char.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+        if (LETTERS[base]) return `[${LETTERS[base]}]`;
+        return /\s/.test(char) ? "\\s+" : char.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      })
+      .join(""),
+  );
+}
+
+// One page of the person's memories: all of them, or the files whose text has the words; each with the time it last
+// changed (OpenViking keeps no other time per file), which is when an event was added.
+async function memoryPage(query) {
+  const conf = memoryServer();
+  const root = `viking://user/${conf.user}`;
+  const scope = query.repo ? `${root}/peers/${query.repo}/memories` : root;
+  // The times come from the listing, so a search asks for both at once.
+  const listing = memoryCall(conf, "/search/glob", { pattern: "**/*.md", uri: scope, node_limit: 20000, extra_fields: ["modTime"] });
+  let rows;
+  if (query.text) {
+    // Every word (or "quoted phrase") must be somewhere in the memory, in any order: one grep each, then the files
+    // all of them hit. Lines are matched, so the words of one memory may sit on different lines.
+    const terms = memoryTerms(query.text);
+    const [files, ...found] = await Promise.all([
+      listing,
+      ...terms.map((term) =>
+        memoryCall(conf, "/search/grep", { uri: scope, exclude_uri: `${root}/sessions`, pattern: term, case_insensitive: true, node_limit: 2000 }),
+      ),
+    ]);
+    const times = new Map((files.matches ?? []).map((m) => [m.uri, m.modTime]));
+    const byFile = new Map();
+    found.forEach((result, index) => {
+      for (const hit of result.matches ?? []) {
+        if (!isMemoryFile(hit.uri)) continue;
+        if (!byFile.has(hit.uri)) byFile.set(hit.uri, { uri: hit.uri, at: times.get(hit.uri), lines: [], hits: new Set() });
+        const file = byFile.get(hit.uri);
+        file.hits.add(index);
+        const line = String(hit.content ?? "").trim();
+        if (!file.lines.includes(line)) file.lines.push(line);
+      }
+    });
+    rows = [...byFile.values()].filter((file) => file.hits.size === terms.length);
+  } else {
+    const found = await listing;
+    rows = (found.matches ?? []).filter((m) => !m.isDir && isMemoryFile(m.uri)).map((m) => ({ uri: m.uri, at: m.modTime }));
+  }
+  if (query.sort) rows.sort((a, b) => String(query.sort === "new" ? b.at : a.at).localeCompare(String(query.sort === "new" ? a.at : b.at)));
+  const pages = Math.max(1, Math.ceil(rows.length / MEMORY_PAGE));
+  const page = Math.min(query.page, pages);
+  const clean = (text, max) => String(text ?? "").replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").slice(0, max);
+  return {
+    connected: true,
+    url: conf.url.replace(/\/+$/, ""),
+    text: query.text,
+    repo: query.repo,
+    sort: query.sort,
+    total: rows.length,
+    page,
+    pages,
+    rows: rows.slice((page - 1) * MEMORY_PAGE, page * MEMORY_PAGE).map((row) => {
+      const where = memoryWhere(row.uri);
+      return {
+        uri: clean(row.uri, 400),
+        repo: plain(where.repo),
+        type: plain(where.type),
+        title: plain(where.title),
+        at: row.at ? String(row.at).slice(0, 16).replace("T", " ") : "",
+        lines: (row.lines ?? []).slice(0, 2).map((line) => clean(line, 160)),
+      };
+    }),
+  };
+}
+
+async function memoryText(query) {
+  const found = await memoryPage(query);
+  const { page, pages } = found;
+  const order = { new: "newest first", old: "oldest first" }[query.sort];
+  const what = [query.text ? `"${plain(query.text)}"` : "all", query.repo ? `in ${query.repo}` : "", order].filter(Boolean).join(" ");
+  const lines = [`Your memories (${found.url}), ${what}: ${found.total} file(s), page ${page} of ${pages}`];
+  for (const row of found.rows) {
+    lines.push("", `${row.at ? `${row.at}  ` : ""}${row.repo} · ${row.type} · ${row.title}`);
+    for (const line of row.lines) lines.push(`    ${line}`);
+    lines.push(`    ${row.uri}`);
+  }
+  if (!found.total) lines.push("", "Nothing found.");
+  const next = [query.text, query.here ? "here" : "", query.sort ? `--${query.sort === "new" ? "newest" : "oldest"}` : "", page < pages ? `page ${page + 1}` : ""].filter(Boolean).join(" ");
+  lines.push("", page < pages ? `Next: /peer-all ${next}` : "", `Search: /peer-all <words> · this repository only: /peer-all here <words> · by time: --newest or --oldest · edit or delete: OpenViking Studio, ${found.url}/studio/`);
+  return lines.filter((line, i, all) => line || all[i - 1]).join("\n").trim();
+}
+
 // ---- main ----
 
 const [command, ...args] = process.argv.slice(2);
@@ -733,8 +1201,28 @@ try {
       await logout();
       break;
     case "list":
-      console.log(await listText(signedIn()));
+      // `--json` is for the thread-mark mod's pane: the hub's list as it came, plus who is asking.
+      if (args.includes("--json")) {
+        const saved = signedIn();
+        const list = await call(saved, "GET", `/workspaces/${saved.workspace}/agents`);
+        console.log(JSON.stringify({ ...list, you: saved.email }));
+      } else console.log(await listText(signedIn()));
+      break;
+    case "thread": {
+      // `peer thread --json <session id>` is for the thread-mark mod's pane.
+      const session = args.find((arg) => !arg.startsWith("--"));
+      if (!validSession(session)) throw new Error("usage: peer thread [--json] <claude code session id>");
+      const memories = await threadMemories(session);
+      if (args.includes("--json")) console.log(JSON.stringify(memories));
+      else if (!memories.connected) console.log(`Peer: ${memories.reason}`);
+      else if (!memories.saves.length) console.log("This thread has not saved anything to memory yet.");
+      else
+        for (const save of memories.saves) {
+          console.log(save.at);
+          for (const item of save.items) console.log(`  ${item.change} ${item.type} "${item.name}": ${item.lines.join(" / ")}${item.systemText ? "  [holds Claude Code's own text]" : ""}`);
+        }
       break;
+    }
     case "status":
       status();
       break;
@@ -752,6 +1240,17 @@ try {
       // A hook never breaks the person's session: whatever goes wrong, it exits 0.
       await (args[0]?.startsWith("team-") ? teamHook(args[0]) : hook(args[0])).catch((error) => log(`hook ${args[0]} failed: ${error?.message ?? error}`));
       break;
+    case "all": {
+      // `peer all --json …` is for the thread-mark mod's pane; without a personal OpenViking it says so.
+      const json = args.includes("--json");
+      const query = memoryQuery(args.filter((arg) => arg !== "--json"), process.cwd());
+      if (!json) console.log(await memoryText(query));
+      else {
+        const found = await memoryPage(query).catch((error) => ({ connected: false, reason: error.message }));
+        console.log(JSON.stringify(found));
+      }
+      break;
+    }
     case "team":
       if (args[0] === "connect") await teamConnect(args.slice(1));
       else if (args[0] === "status") teamStatus();

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

@@ -1,7 +1,7 @@
 {
   "name": "peer-thread-mark",
-  "version": "0.4.2",
-  "description": "Marks a Claude Code thread shared with Peer (/peer) with a band above the prompt, with /peer stop and /peer start",
+  "version": "0.4.14",
+  "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"
 }