@webinson/peer 0.4.1 → 0.4.5

package/README.md

@@ -18,13 +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 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
-  state, and the threads that stopped in the last hours.
+  state, and the threads that stopped in the last hours. With the plugin installed it opens a `Peer` pane beside
+  the chat that reloads every 15 s; without it, or where no pane fits, the hook answers with the list.
 
-`/peer`, `/peer stop` and `/peer-list` are answered by the hook before the prompt reaches the model,
-so they cost no tokens. `peer list` prints the same list in a terminal.
+`/peer stop` and `/peer-list` are answered by the hook before the prompt reaches the model, so they
+cost no tokens. A bare `/peer` is shared by the hook too, then reaches the agent, which confirms it in a
+line or two: one short turn, instead of Claude Code's "hook blocked your prompt" warning. `/peer-thread` opens a pane with what this thread saved to your own OpenViking memory, in sentences (read-only;
+`peer thread <session id>` prints it). `peer list` prints the same list in a terminal; `peer list --json` gives the pane the hub's list as it came.
 
 ## What is shared
 
@@ -56,7 +62,7 @@ only the hook knows the session id. After that the hooks report that thread arou
 mark. A hook never fails or holds up a session: it gives the hub 3 seconds and drops what does not
 go through. What the hooks did, without any prompt text, is in `~/.peer/hook.log`.
 
-If `/peer` reaches the model ("the hook did not run"), `peer doctor` checks the sign-in, the hooks in
+If the agent says the hook did not run, or `/peer stop` reaches the model, `peer doctor` checks the sign-in, the hooks in
 Claude Code's settings and the paths they run, and runs the hook the way Claude Code does. An app
 or IDE that starts Claude through the Agent SDK may not load `~/.claude/settings.json`; `claude` in
 a terminal does.
@@ -71,21 +77,34 @@ If your team runs a shared project memory (an OpenViking server, see the Peer Hu
 `deploy/team-memory/`), connect this computer once, inside the project's repository:
 
 ```bash
-printf '%s' "$YOUR_TEAM_KEY" | peer team connect https://memory.example.com --as <you> --project <id>
+printf '%s' "$YOUR_TEAM_KEY" | peer team connect https://memory.example.com --as <you>
 ```
 
-The key comes on stdin and is saved in `~/.peer/team-memory/member.json` (mode 0600). After that, the first
+The project is the one your Peer workspace keeps this repository in, with all of that project's repositories;
+a repository in no Hub project (or without `peer login`) is a project of its own, named by its normalized
+origin (`github.com-acme-shop`). `--project <id>` names another. The key comes on stdin and is saved in `~/.peer/team-memory/member.json` (mode 0600). After that, the first
 prompt of every thread in that repository (and the first after a resume or compaction) gets at most five
 teammates' published findings that match it: verified or observed, not your own, about 1,500 tokens,
 fenced as data from colleagues; a page whose paths changed in three or more commits since it was last
 confirmed comes marked "may be stale". The prompt's first 400 characters go to the team server as the search
 query. Nothing else of the thread is sent. `peer team status` shows the connection and the last recalls.
 
+## Your own memory
+
+`/peer-all` lists what your personal OpenViking (as `~/.openviking/ovcli.conf` points to it) remembers, 20 to a
+page: `/peer-all page 2`; `--newest` or `--oldest` orders it by the time a memory last changed (for an event, when it
+was added). With the thread mark installed it opens a pane with a search field that searches as you type, a this-repository switch and a time
+button that goes unsorted, newest first, oldest first and back. `/peer-all <words>` searches the memories' full text: every word, in
+any order, anywhere in a memory, case and diacritics left aside (`pamat` finds "pamäť"); `"a phrase"` in quotes keeps
+its words together; conversation archives are left out, and `here` keeps it to the current repository:
+`/peer-all here batch limit`. The hook answers, so the list reaches you and never the thread or its capture.
+`peer all …` prints the same in a terminal. Editing and deleting stay in OpenViking Studio.
+
 ## Other commands
 
 ```
 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 connect to the team's memory server (see above)
 peer team status  the team server, project and the last recalls
 peer install      set Claude Code up again

package/bin/peer.mjs

@@ -21,6 +21,12 @@ const HOOK_TIMEOUT_S = 10;
 const HUB_TIMEOUT_MS = 3000;
 // Why a hook did what it did, without any prompt text: `peer doctor` shows the end of it.
 const HOOK_LOG = path.join(HOME, "hook.log");
+// The thread mark: a Claude Code plugin shipped in this package (mod/), a marketplace of one plugin read
+// from that folder, so updating the package updates it.
+const CLAUDE_BIN = process.env.PEER_CLAUDE || "claude";
+const MOD_DIR = path.join(path.dirname(SELF), "..", "mod");
+const MOD = "peer-thread-mark";
+const MARKETPLACE = "webinson-peer";
 
 const HELP = `peer: share chosen agent threads with your team
 
@@ -28,12 +34,16 @@ 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 install      set up Claude Code again (hooks and the two commands)
+  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
 
@@ -236,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 {
@@ -267,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
@@ -316,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": `---
@@ -334,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.
 `,
 };
 
@@ -371,14 +400,50 @@ 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();
+}
+
+function claudeCli(args) {
+  return execFileSync(CLAUDE_BIN, args, { encoding: "utf8", timeout: 60000, stdio: ["ignore", "pipe", "pipe"] });
+}
+
+// The band above the prompt in shared threads. Optional: /peer works without it, so a failure only says so.
+function installMark() {
+  if (!fs.existsSync(path.join(MOD_DIR, ".claude-plugin", "marketplace.json"))) return;
+  const install = () => claudeCli(["plugin", "install", MOD, "--marketplace", MOD_DIR, "--scope", "user"]);
+  try {
+    try {
+      install();
+    } catch {
+      // A marketplace of that name added from an older place (another install of this package) is replaced.
+      try {
+        claudeCli(["plugin", "marketplace", "remove", MARKETPLACE]);
+      } catch {}
+      install();
+    }
+    console.log(`Claude Code: the thread mark (${MOD}), a band above the prompt in shared threads, from ${MOD_DIR}.`);
+  } catch (error) {
+    const reason = String(error.stderr || error.message).trim().split("\n").pop();
+    console.log(`Claude Code: the thread mark was not installed (${reason}); /peer works without it.`);
+    console.log(`  To add it later: claude plugin install ${MOD} --marketplace "${MOD_DIR}"`);
+  }
+}
+
+function uninstallMark() {
+  for (const args of [["plugin", "uninstall", `${MOD}@${MARKETPLACE}`], ["plugin", "marketplace", "remove", MARKETPLACE]]) {
+    try {
+      claudeCli(args);
+    } catch {}
+  }
 }
 
 function uninstall() {
   const settings = readJson(SETTINGS);
   if (settings) writeJson(SETTINGS, withoutOurHooks(settings), 0o644);
   for (const name of Object.keys(COMMAND_FILES)) fs.rmSync(path.join(COMMANDS, name), { force: true });
-  console.log("Claude Code: Peer's hooks and commands removed.");
+  uninstallMark();
+  console.log("Claude Code: Peer's hooks, commands and thread mark removed.");
 }
 
 // ---- signing in ----
@@ -446,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;
@@ -470,8 +535,11 @@ async function doctor() {
   }
 
   try {
-    const version = execFileSync("claude", ["--version"], { encoding: "utf8", timeout: 10000, stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const version = execFileSync(CLAUDE_BIN, ["--version"], { encoding: "utf8", timeout: 10000, stdio: ["ignore", "pipe", "ignore"] }).trim();
     ok(`Claude Code ${version} (Peer is tested with 2.1.316)`);
+    const mark = JSON.parse(claudeCli(["plugin", "list", "--json"])).find((p) => p.id === `${MOD}@${MARKETPLACE}`);
+    if (mark?.enabled) ok(`the thread mark (${MOD}) is installed`);
+    else console.log(`  --    the thread mark (${MOD}, a band above the prompt) is ${mark ? "turned off" : "not installed"}: \`peer install\` adds it`);
   } catch {
     console.log("  ?     `claude` is not on this terminal's PATH, so its version is unknown");
   }
@@ -500,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.
@@ -526,11 +594,78 @@ 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+/, ""));
+}
+
+// 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 ?? ""));
+
+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: [] };
+    throw error;
+  }
+  const saves = [];
+  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 ?? {};
+    const items = [
+      ...(ops.adds ?? []).map((op) => ({ change: "added", type: op.memory_type, name: memoryName(op.uri), lines: [summaryOf(op.after)], systemText: hasSystemText(op.after) })),
+      ...(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) })),
+      ...(ops.deletes ?? []).map((op) => ({ change: "removed", type: op.memory_type, name: memoryName(op.uri), lines: [summaryOf(op.before)], systemText: 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)) }));
+    saves.push({ at: diff.extracted_at ?? archive.modTime, items });
+  }
+  return { connected: true, saves: saves.sort((a, b) => String(b.at).localeCompare(String(a.at))) };
+}
+
 // ---- 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
@@ -542,7 +677,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, "")
@@ -565,9 +703,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");
@@ -577,11 +725,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();
@@ -676,6 +827,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);
@@ -688,8 +992,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;
@@ -707,6 +1031,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/.claude-plugin/marketplace.json

@@ -0,0 +1,11 @@
+{
+  "name": "webinson-peer",
+  "owner": { "name": "Webinson" },
+  "plugins": [
+    {
+      "name": "peer-thread-mark",
+      "source": "./peer-thread-mark",
+      "description": "Marks a Claude Code thread shared with Peer (/peer) with a band above the prompt"
+    }
+  ]
+}

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

@@ -0,0 +1,7 @@
+{
+  "name": "peer-thread-mark",
+  "version": "0.4.11",
+  "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/hooks.json

@@ -0,0 +1 @@
+{ "modules": ["./register.tsx"] }