feat(honcho): add self-log read tools and arbitrary-peer query escape hatch

Closes the read-side gap — self-conclusions written via observed='self' had
no mid-session retrieval surface. Adds:

- query_self_conclusions: semantic search on the AI peer's own self-log
- list_self_conclusions: paginated audit of self-conclusions
- query_peer_conclusions: cross-peer query with explicit observer/observed
  peer names — escape hatch for multi-agent setups (Claude + Codex + Hermes)
  and cell-B queries (user's evaluations of a specific agent)

Three-tool pattern per operation: sharp facades for the common cases
(_user_, _self_) plus a peer-name-addressable variant for arbitrary edges.
Facades win on MCP discoverability; the escape hatch scales to N agents
without tool sprawl. Read API now mirrors the write API.

list_self_conclusions and query_self_conclusions are mode-independent —
aiPeer always observes itself regardless of unified vs directional config.

Author: offendingcommit

plugins/honcho/dist/mcp-server.js

@@ -29740,7 +29740,7 @@ For either target, the test before writing is: "would future-me find this useful
         },
         {
           name: "query_conclusions",
-          description: "Semantic search across saved conclusions about the user. Use this to find specific knowledge Honcho has derived \u2014 more targeted than list_conclusions (which is just paginated). Returns conclusions ranked by relevance.",
+          description: "Semantic search across saved conclusions about the user. Returns conclusions ranked by relevance. For your own self-log, use query_self_conclusions. For cross-peer queries (multi-agent setups), use query_peer_conclusions.",
           inputSchema: {
             type: "object",
             properties: {
@@ -29757,6 +29757,49 @@ For either target, the test before writing is: "would future-me find this useful
             required: ["query"]
           }
         },
+        {
+          name: "query_self_conclusions",
+          description: "Semantic search across YOUR cross-session self-log (conclusions you've written about yourself as the AI peer via create_conclusion(observed='self')). Use to retrieve patterns, discoveries, and course-corrections you've logged in past sessions on a related topic. Symmetric with query_conclusions but scoped to the AI peer.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: { type: "string", description: "Semantic query" },
+              top_k: { type: "number", description: "Max results (default 10)", default: 10 }
+            },
+            required: ["query"]
+          }
+        },
+        {
+          name: "list_self_conclusions",
+          description: "Paginated list of YOUR self-log conclusions. Use to audit what you've recorded or find IDs for deletion. For semantic search, prefer query_self_conclusions.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              page: { type: "number", description: "Page number (1-indexed)", default: 1 },
+              size: { type: "number", description: "Results per page (max 50)", default: 20 }
+            }
+          }
+        },
+        {
+          name: "query_peer_conclusions",
+          description: "Semantic search across conclusions on an arbitrary (observer, observed) peer edge. Escape hatch for multi-agent setups (Claude + Codex + Hermes etc.) where you need to address peers by name rather than alias. Common cases: (a) cross-peer queries \u2014 what does another agent know about the user; (b) cell-B queries \u2014 what does the user think about a specific agent (observer=user, observed=<agent>). For self-log queries, prefer query_self_conclusions; for default user queries, prefer query_conclusions.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: { type: "string", description: "Semantic query" },
+              observed_peer: {
+                type: "string",
+                description: "Peer name being observed (the subject of the conclusions). Required."
+              },
+              observer_peer: {
+                type: "string",
+                description: "Peer name doing the observing. Defaults to the AI peer (caller). Pass user peer name to query cell B (user's evaluations of an agent)."
+              },
+              top_k: { type: "number", description: "Max results (default 10)", default: 10 }
+            },
+            required: ["query", "observed_peer"]
+          }
+        },
         {
           name: "schedule_dream",
           description: "Trigger Honcho's background memory consolidation (a 'dream'). Honcho will merge redundant conclusions and derive higher-level insights about the user. Use after a long or insight-rich session to improve memory quality. Returns immediately; consolidation runs async on Honcho's side.",
@@ -30163,6 +30206,76 @@ For either target, the test before writing is: "would future-me find this useful
         };
       }
     }
+    if (name === "query_self_conclusions" || name === "list_self_conclusions") {
+      try {
+        const aiPeer = await honcho.peer(config2.aiPeer);
+        const conclusionScope = aiPeer.conclusionsOf(config2.aiPeer);
+        if (name === "query_self_conclusions") {
+          const query = args?.query;
+          const topK = args?.top_k ?? 10;
+          const conclusions = await conclusionScope.query(query, topK);
+          const items2 = (conclusions ?? []).map((c) => ({
+            id: c.id,
+            content: c.content,
+            sessionId: c.sessionId ?? c.session_id,
+            createdAt: c.createdAt ?? c.created_at
+          }));
+          return { content: [{ type: "text", text: JSON.stringify(items2, null, 2) }] };
+        }
+        const page = args?.page ?? 1;
+        const size = Math.min(args?.size ?? 20, 100);
+        const result = await conclusionScope.list({ page, size });
+        const items = result.items.map((c) => ({
+          id: c.id,
+          content: c.content,
+          createdAt: c.createdAt
+        }));
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ items, total: result.total, page: result.page, pages: result.pages }, null, 2)
+          }]
+        };
+      } catch (error3) {
+        return {
+          content: [{ type: "text", text: `Error: ${error3 instanceof Error ? error3.message : String(error3)}` }],
+          isError: true
+        };
+      }
+    }
+    if (name === "query_peer_conclusions") {
+      try {
+        const query = args?.query;
+        const observedPeerName = args?.observed_peer;
+        const observerPeerName = args?.observer_peer ?? config2.aiPeer;
+        const topK = args?.top_k ?? 10;
+        if (!observedPeerName) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ success: false, error: "observed_peer is required" }) }],
+            isError: true
+          };
+        }
+        const observer = await honcho.peer(observerPeerName);
+        const conclusions = await observer.conclusionsOf(observedPeerName).query(query, topK);
+        const items = (conclusions ?? []).map((c) => ({
+          id: c.id,
+          content: c.content,
+          sessionId: c.sessionId ?? c.session_id,
+          createdAt: c.createdAt ?? c.created_at
+        }));
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ observer: observerPeerName, observed: observedPeerName, items }, null, 2)
+          }]
+        };
+      } catch (error3) {
+        return {
+          content: [{ type: "text", text: `Error: ${error3 instanceof Error ? error3.message : String(error3)}` }],
+          isError: true
+        };
+      }
+    }
     const sessionName = getSessionName(cwd);
     try {
       const session = await honcho.session(sessionName);

plugins/honcho/src/mcp/server.ts

@@ -661,7 +661,7 @@ export async function runMcpServer(): Promise<void> {
         },
         {
           name: "query_conclusions",
-          description: "Semantic search across saved conclusions about the user. Use this to find specific knowledge Honcho has derived — more targeted than list_conclusions (which is just paginated). Returns conclusions ranked by relevance.",
+          description: "Semantic search across saved conclusions about the user. Returns conclusions ranked by relevance. For your own self-log, use query_self_conclusions. For cross-peer queries (multi-agent setups), use query_peer_conclusions.",
           inputSchema: {
             type: "object",
             properties: {
@@ -678,6 +678,49 @@ export async function runMcpServer(): Promise<void> {
             required: ["query"],
           },
         },
+        {
+          name: "query_self_conclusions",
+          description: "Semantic search across YOUR cross-session self-log (conclusions you've written about yourself as the AI peer via create_conclusion(observed='self')). Use to retrieve patterns, discoveries, and course-corrections you've logged in past sessions on a related topic. Symmetric with query_conclusions but scoped to the AI peer.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: { type: "string", description: "Semantic query" },
+              top_k: { type: "number", description: "Max results (default 10)", default: 10 },
+            },
+            required: ["query"],
+          },
+        },
+        {
+          name: "list_self_conclusions",
+          description: "Paginated list of YOUR self-log conclusions. Use to audit what you've recorded or find IDs for deletion. For semantic search, prefer query_self_conclusions.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              page: { type: "number", description: "Page number (1-indexed)", default: 1 },
+              size: { type: "number", description: "Results per page (max 50)", default: 20 },
+            },
+          },
+        },
+        {
+          name: "query_peer_conclusions",
+          description: "Semantic search across conclusions on an arbitrary (observer, observed) peer edge. Escape hatch for multi-agent setups (Claude + Codex + Hermes etc.) where you need to address peers by name rather than alias. Common cases: (a) cross-peer queries — what does another agent know about the user; (b) cell-B queries — what does the user think about a specific agent (observer=user, observed=<agent>). For self-log queries, prefer query_self_conclusions; for default user queries, prefer query_conclusions.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: { type: "string", description: "Semantic query" },
+              observed_peer: {
+                type: "string",
+                description: "Peer name being observed (the subject of the conclusions). Required.",
+              },
+              observer_peer: {
+                type: "string",
+                description: "Peer name doing the observing. Defaults to the AI peer (caller). Pass user peer name to query cell B (user's evaluations of an agent).",
+              },
+              top_k: { type: "number", description: "Max results (default 10)", default: 10 },
+            },
+            required: ["query", "observed_peer"],
+          },
+        },
         {
           name: "schedule_dream",
           description: "Trigger Honcho's background memory consolidation (a 'dream'). Honcho will merge redundant conclusions and derive higher-level insights about the user. Use after a long or insight-rich session to improve memory quality. Returns immediately; consolidation runs async on Honcho's side.",
@@ -1120,6 +1163,83 @@ export async function runMcpServer(): Promise<void> {
       }
     }
 
+    // Self-log facade: aiPeer observes itself. Independent of observation mode.
+    if (name === "query_self_conclusions" || name === "list_self_conclusions") {
+      try {
+        const aiPeer = await honcho.peer(config.aiPeer);
+        const conclusionScope = aiPeer.conclusionsOf(config.aiPeer);
+
+        if (name === "query_self_conclusions") {
+          const query = args?.query as string;
+          const topK = (args?.top_k as number) ?? 10;
+          const conclusions = await conclusionScope.query(query, topK);
+          const items = (conclusions ?? []).map((c: any) => ({
+            id: c.id,
+            content: c.content,
+            sessionId: c.sessionId ?? c.session_id,
+            createdAt: c.createdAt ?? c.created_at,
+          }));
+          return { content: [{ type: "text", text: JSON.stringify(items, null, 2) }] };
+        }
+
+        const page = (args?.page as number) ?? 1;
+        const size = Math.min((args?.size as number) ?? 20, 100);
+        const result = await conclusionScope.list({ page, size });
+        const items = result.items.map((c: any) => ({
+          id: c.id,
+          content: c.content,
+          createdAt: c.createdAt,
+        }));
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ items, total: result.total, page: result.page, pages: result.pages }, null, 2),
+          }],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true,
+        };
+      }
+    }
+
+    // Escape hatch: arbitrary (observer, observed) peer-name addressing for
+    // multi-agent setups. Default observer = aiPeer (caller).
+    if (name === "query_peer_conclusions") {
+      try {
+        const query = args?.query as string;
+        const observedPeerName = args?.observed_peer as string;
+        const observerPeerName = (args?.observer_peer as string) ?? config.aiPeer;
+        const topK = (args?.top_k as number) ?? 10;
+        if (!observedPeerName) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ success: false, error: "observed_peer is required" }) }],
+            isError: true,
+          };
+        }
+        const observer = await honcho.peer(observerPeerName);
+        const conclusions = await observer.conclusionsOf(observedPeerName).query(query, topK);
+        const items = (conclusions ?? []).map((c: any) => ({
+          id: c.id,
+          content: c.content,
+          sessionId: c.sessionId ?? c.session_id,
+          createdAt: c.createdAt ?? c.created_at,
+        }));
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ observer: observerPeerName, observed: observedPeerName, items }, null, 2),
+          }],
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true,
+        };
+      }
+    }
+
     // ── Honcho session tools ──
 
     const sessionName = getSessionName(cwd);