pi-harness-runtime 1.1.420 → 1.1.422

package/harness/honcho-init.ts

@@ -55,6 +55,30 @@ type McpToolCallResult =
   | { ok: true; result?: unknown }
   | { ok: false; error?: Error };
 
+/**
+ * Did the adapter refuse the call?
+ *
+ * The check is a type guard and not a plain `!result.ok`: the root project
+ * runs without strictNullChecks, and there the discriminant of a union is
+ * not narrowed - the guard narrows in every setting.
+ */
+function isToolCallFailure(
+  result: McpToolCallResult
+): result is { ok: false; error?: Error } {
+  return result.ok === false;
+}
+
+/**
+ * Did the adapter refuse the registration?
+ *
+ * The same reason as isToolCallFailure: the guard narrows in every setting.
+ */
+function isRegistrationFailure(
+  result: NonNullable<McpRuntimeRegistrationRequest["result"]>
+): result is { ok: false; error: Error } {
+  return result.ok === false;
+}
+
 /**
  * Honcho session identity
  */
@@ -153,6 +177,79 @@ let _disposed = false;
 // MCP Tool Calls
 // ---------------------------------------------------------------------------
 
+/**
+ * The payload of a Honcho tool call.
+ *
+ * The MCP server answers with the MCP shape: the payload is the TEXT of the
+ * first content block, and for the tools that answer with data that text is
+ * JSON. The tools that only confirm something ("Peers added to session
+ * successfully") answer with plain text.
+ *
+ * The harness therefore has to unwrap the content block before it can read a
+ * peer id - reading `result.id` on the raw MCP result finds nothing, because
+ * the id lives in the JSON text of the first block.
+ */
+export function honchoPayload(result: unknown): {
+  data: Record<string, unknown> | null;
+  parsed: unknown;
+  text: string;
+} {
+  const content = (result as { content?: unknown })?.content;
+  const first = Array.isArray(content) ? content[0] : undefined;
+  const text = typeof (first as { text?: unknown })?.text === "string" ? (first as { text: string }).text : "";
+  if (text === "") {
+    return { data: null, parsed: null, text: "" };
+  }
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return { data: parsed as Record<string, unknown>, parsed, text };
+    }
+    if (parsed !== null && typeof parsed === "object") {
+      return { data: null, parsed, text };
+    }
+  } catch {
+    // Not JSON: the tool confirmed with plain text.
+  }
+  return { data: null, parsed: null, text };
+}
+
+/**
+ * The entries of a list tool ("peers", "sessions").
+ *
+ * The server answers with the list under its own key and the paging beside
+ * it. A bare array is accepted as well.
+ */
+function listEntriesFrom(parsed: unknown, key: string): Record<string, unknown>[] {
+  const list = (parsed as Record<string, unknown> | null)?.[key];
+  if (Array.isArray(list)) {
+    return list.filter((entry): entry is Record<string, unknown> => typeof entry === "object" && entry !== null);
+  }
+  if (Array.isArray(parsed)) {
+    return parsed.filter((entry): entry is Record<string, unknown> => typeof entry === "object" && entry !== null);
+  }
+  return [];
+}
+
+/**
+ * The peer id in the answer of a peer tool.
+ *
+ * The server answers with `peer_id`; the answers that carry a nested peer
+ * use `id`. Both are accepted so a server change cannot silently empty the
+ * identity.
+ */
+function peerIdFrom(data: Record<string, unknown> | null): string | null {
+  if (!data) {
+    return null;
+  }
+  const direct = data.peer_id ?? data.id;
+  if (typeof direct === "string" && direct !== "") {
+    return direct;
+  }
+  const nested = (data.peer as { id?: unknown } | undefined)?.id;
+  return typeof nested === "string" && nested !== "" ? nested : null;
+}
+
 /**
  * Call a tool on the Honcho MCP server through the adapter.
  * Returns actual result from the MCP server.
@@ -184,21 +281,29 @@ async function callHonchoTool(
   // Emit tool call
   piEvents.emit(MCP_RUNTIME_TOOL_CALL_EVENT, request);
 
-  // Wait for result - adapter assigns a Promise to request.result
-  if (request.result === undefined) {
+  // Read result immediately after emit. The value goes into a local: reading
+  // the property again after the emit would lose the narrowing, because a
+  // call may change the property.
+  const pending = request.result;
+  if (pending === undefined) {
     logServiceEvent({ ts: new Date().toISOString(), level: "error", service: "honcho", operation: "tool_call", phase: "failed", tool: toolName, reason: "no response from adapter" });
     return { success: false, error: "No response from MCP adapter" };
   }
 
-  // request.result is a Promise from the adapter
-  const result = await request.result;
-  
-  logServiceEvent({ ts: new Date().toISOString(), level: "debug", service: "honcho", operation: "tool_call", phase: "completed", tool: toolName, result: JSON.stringify(result).slice(0, 200) });
+  // The adapter sets the promise during the emit - await it.
+  const result = await pending;
 
-  if (!result.ok) {
-    return { success: false, error: result.error?.message ?? "Unknown error" };
+  if (isToolCallFailure(result)) {
+    // The adapter hands back an Error instance: JSON.stringify would show an
+    // empty object, so the message goes into the log on its own. Without it
+    // a failing call reads like "Unknown error" and names nothing.
+    const message = result.error?.message ?? "Unknown error";
+    logServiceEvent({ ts: new Date().toISOString(), level: "error", service: "honcho", operation: "tool_call", phase: "failed", tool: toolName, error: message });
+    return { success: false, error: message };
   }
 
+  logServiceEvent({ ts: new Date().toISOString(), level: "debug", service: "honcho", operation: "tool_call", phase: "completed", tool: toolName, result: JSON.stringify(result.result).slice(0, 200) });
+
   return { success: true, result: result.result };
 }
 
@@ -252,7 +357,19 @@ async function ensureWorkspace(workspaceName: string): Promise<string | null> {
   });
 
   if (inspectResult.success && inspectResult.result) {
-    const response = inspectResult.result as { workspace?: { id?: string }; id?: string; metadata?: Record<string, unknown> };
+    // The server answers with the MCP envelope: the JSON sits in the text of
+    // the first content block. Reading the envelope directly would find
+    // nothing and silently fall back to the workspace name.
+    const parsed = honchoPayload(inspectResult.result).parsed as {
+      workspace?: { id?: string };
+      id?: string;
+      metadata?: Record<string, unknown>;
+    } | null;
+    const response: {
+      workspace?: { id?: string };
+      id?: string;
+      metadata?: Record<string, unknown>;
+    } = parsed ?? {};
     const workspaceId = response.workspace?.id ?? response.id ?? workspaceName;
     savePersistedWorkspace(workspaceId, workspaceName);
     
@@ -285,25 +402,31 @@ async function ensureUserPeer(
   workspaceId: string,
   userName: string
 ): Promise<string | null> {
-  const result = await callHonchoTool("create_user", {
+  // The server's peer API: create_peer is a get-or-create.
+  const result = await callHonchoTool("create_peer", {
     workspace_id: workspaceId,
-    name: userName,
+    peer_id: userName,
   });
 
-  if (result.success && result.result) {
-    const response = result.result as { id?: string; user?: { id?: string } };
-    return response.id ?? response.user?.id ?? null;
+  if (result.success) {
+    const peerId = peerIdFrom(honchoPayload(result.result).data);
+    if (peerId) {
+      return peerId;
+    }
   }
 
-  // Try get_or_create_user as fallback
-  const getResult = await callHonchoTool("get_or_create_user", {
+  // The peer may exist already: list the peers and look for it.
+  const listResult = await callHonchoTool("list_peers", {
     workspace_id: workspaceId,
-    name: userName,
+    size: 100,
   });
-
-  if (getResult.success && getResult.result) {
-    const response = getResult.result as { id?: string };
-    return response.id ?? null;
+  if (listResult.success) {
+    for (const peer of listEntriesFrom(honchoPayload(listResult.result).parsed, "peers")) {
+      const peerId = peerIdFrom(peer);
+      if (peerId === userName) {
+        return peerId;
+      }
+    }
   }
 
   logServiceEvent({
@@ -325,14 +448,29 @@ async function ensureAssistantPeer(
   workspaceId: string,
   assistantName: string
 ): Promise<string | null> {
-  const result = await callHonchoTool("create_assistant", {
+  const result = await callHonchoTool("create_peer", {
     workspace_id: workspaceId,
-    name: assistantName,
+    peer_id: assistantName,
   });
 
-  if (result.success && result.result) {
-    const response = result.result as { id?: string; assistant?: { id?: string } };
-    return response.id ?? response.assistant?.id ?? null;
+  if (result.success) {
+    const peerId = peerIdFrom(honchoPayload(result.result).data);
+    if (peerId) {
+      return peerId;
+    }
+  }
+
+  const listResult = await callHonchoTool("list_peers", {
+    workspace_id: workspaceId,
+    size: 100,
+  });
+  if (listResult.success) {
+    for (const peer of listEntriesFrom(honchoPayload(listResult.result).parsed, "peers")) {
+      const peerId = peerIdFrom(peer);
+      if (peerId === assistantName) {
+        return peerId;
+      }
+    }
   }
 
   logServiceEvent({
@@ -356,59 +494,97 @@ async function ensureSession(
   assistantPeerId: string,
   sessionId: string
 ): Promise<string | null> {
+  // The server's session API: create_session is a get-or-create, and the
+  // peers join the session with their own call.
   const result = await callHonchoTool("create_session", {
     workspace_id: workspaceId,
-    user_id: userPeerId,
-    assistant_id: assistantPeerId,
-    id: sessionId,
+    session_id: sessionId,
   });
 
-  if (result.success && result.result) {
-    const response = result.result as { id?: string; session?: { id?: string } };
-    return response.id ?? response.session?.id ?? null;
+  let createdSessionId: string | null = null;
+  if (result.success) {
+    const data = honchoPayload(result.result).data;
+    const id = data?.session_id ?? data?.id;
+    createdSessionId = typeof id === "string" && id !== "" ? id : null;
   }
 
-  // Try get_or_create_session as fallback
-  const getResult = await callHonchoTool("get_or_create_session", {
-    workspace_id: workspaceId,
-    user_id: userPeerId,
-    assistant_id: assistantPeerId,
-    id: sessionId,
-  });
+  if (!createdSessionId) {
+    // The session may exist already: list the sessions and look for it.
+    const listResult = await callHonchoTool("list_sessions", {
+      workspace_id: workspaceId,
+      size: 100,
+    });
+    if (listResult.success) {
+      for (const session of listEntriesFrom(honchoPayload(listResult.result).parsed, "sessions")) {
+        const id = session.session_id ?? session.id;
+        if (typeof id === "string" && id === sessionId) {
+          createdSessionId = id;
+          break;
+        }
+      }
+    }
+  }
 
-  if (getResult.success && getResult.result) {
-    const response = getResult.result as { id?: string };
-    return response.id ?? null;
+  if (!createdSessionId) {
+    logServiceEvent({
+      ts: new Date().toISOString(),
+      level: "error",
+      service: "honcho",
+      operation: "session_failed",
+      phase: "failed",
+      error: result.error ?? "Unknown error",
+    });
+
+    return null;
   }
 
-  logServiceEvent({
-    ts: new Date().toISOString(),
-    level: "error",
-    service: "honcho",
-    operation: "session_failed",
-    phase: "failed",
-    error: result.error ?? "Unknown error",
+  // The peers have to join the session explicitly.
+  const peersResult = await callHonchoTool("add_peers_to_session", {
+    workspace_id: workspaceId,
+    session_id: createdSessionId,
+    peers: [userPeerId, assistantPeerId],
   });
+  if (!peersResult.success) {
+    logServiceEvent({
+      ts: new Date().toISOString(),
+      level: "warn",
+      service: "honcho",
+      operation: "session_peers_failed",
+      phase: "failed",
+      error: peersResult.error ?? "Unknown error",
+      sessionId: createdSessionId,
+    });
+  }
 
-  return null;
+  return createdSessionId;
 }
 
 /**
  * Add a message to the session
  */
 async function addMessage(
+  workspaceId: string,
   sessionId: string,
   peerId: string,
   role: "user" | "assistant",
   content: string,
   messageId?: string
 ): Promise<boolean> {
-  const result = await callHonchoTool("add_message", {
+  // The server takes the messages of a session in one call, and the author
+  // of a message is the peer - the role lives in the metadata.
+  const result = await callHonchoTool("add_messages_to_session", {
+    workspace_id: workspaceId,
     session_id: sessionId,
-    sender_id: peerId,
-    role,
-    content,
-    message_id: messageId,
+    messages: [
+      {
+        peer_id: peerId,
+        content,
+        metadata: {
+          role,
+          ...(messageId ? { message_id: messageId } : {}),
+        },
+      },
+    ],
   });
 
   return result.success;
@@ -423,19 +599,25 @@ async function getContext(
   query: string,
   limit: number = 5
 ): Promise<string | null> {
-  const result = await callHonchoTool("get_context", {
+  // The server has no query-scoped "get_context": the recall is the search,
+  // and the messages it finds are the context.
+  const result = await callHonchoTool("search", {
     workspace_id: workspaceId,
     session_id: sessionId,
     query,
-    limit,
+    message_limit: Math.max(1, Math.min(100, limit)),
   });
 
-  if (result.success && result.result) {
-    const response = result.result as { content?: string; context?: string; text?: string };
-    return response.content ?? response.context ?? response.text ?? null;
+  if (!result.success) {
+    return null;
   }
 
-  return null;
+  const messages = listEntriesFrom(honchoPayload(result.result).parsed, "messages");
+  const texts = messages
+    .map((message) => (typeof message.content === "string" ? message.content : ""))
+    .filter((text) => text !== "");
+
+  return texts.length > 0 ? texts.join("\n") : null;
 }
 
 // ---------------------------------------------------------------------------
@@ -539,16 +721,19 @@ export async function initHoncho(options?: {
   // Emit registration event - adapter writes request.result synchronously
   piEvents.emit(MCP_RUNTIME_REGISTER_EVENT, request);
 
-  // Read result immediately after emit
-  if (request.result === undefined) {
+  // Read result immediately after emit. The value goes into a local: reading
+  // the property again after the emit would lose the narrowing, because a
+  // call may change the property.
+  const registration = request.result;
+  if (registration === undefined) {
     logServiceEvent({ ts: new Date().toISOString(), level: "error", service: "honcho", operation: "mcp_register", phase: "failed", reason: "MCP adapter not responding" });
     logServiceEvent({ ts: new Date().toISOString(), level: "info", service: "honcho", operation: "mcp_register", phase: "failed", helpUrl: "pi install npm:pi-mcp-adapter" });
     honchoStatus.recordFailure("init", "no_listener", { error: "No adapter responded" });
     return null;
   }
 
-  if (!request.result.ok) {
-    const errorMsg = request.result.error?.message ?? "Unknown registration error";
+  if (isRegistrationFailure(registration)) {
+    const errorMsg = registration.error?.message ?? "Unknown registration error";
     
     // Check for duplicate name - an existing server may already be registered
     if (errorMsg.includes("already") || errorMsg.includes("duplicate")) {
@@ -561,7 +746,7 @@ export async function initHoncho(options?: {
     }
   } else {
     // Registration accepted - store handle for disposal
-    _honchoRegistration = request.result.registration;
+    _honchoRegistration = registration.registration;
     logServiceEvent({ ts: new Date().toISOString(), level: "info", service: "honcho", operation: "mcp_register", phase: "completed" });
   }
 
@@ -643,6 +828,9 @@ export async function ensureHonchoIdentity(): Promise<boolean> {
   _honchoMemory.setToolsDiscovered(true);
   _honchoMemory.setWorkspace(workspaceId);
   _honchoMemory.setSession(honchoSessionId);
+  // The peers are the authors of the messages: without them the ingestion
+  // cannot say who said what.
+  _honchoMemory.setPeers(userPeerId, assistantPeerId);
 
   logServiceEvent({ ts: new Date().toISOString(), level: "info", service: "honcho", operation: "memory_init", phase: "completed" });
   honchoStatus.recordSuccess("init", undefined, {
@@ -691,6 +879,7 @@ export async function ingestUserMessage(
   }
 
   return await addMessage(
+    _identity.workspaceId,
     _identity.sessionId,
     _identity.userPeerId,
     "user",
@@ -711,6 +900,7 @@ export async function ingestAssistantMessage(
   }
 
   return await addMessage(
+    _identity.workspaceId,
     _identity.sessionId,
     _identity.assistantPeerId,
     "assistant",

package/harness/honcho-memory.ts

@@ -12,7 +12,7 @@
  */
 
 import { logServiceEvent, honchoStatus } from "./service-diagnostics.js";
-import { honchoToolCall } from "./honcho-init.js";
+import { honchoPayload, honchoToolCall } from "./honcho-init.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
@@ -308,6 +308,8 @@ export class HonchoMemory {
   private toolsDiscovered = false;
   private workspaceId: string | null = null;
   private sessionId: string | null = null;
+  private userPeerId: string | null = null;
+  private assistantPeerId: string | null = null;
   private _disposed = false;
 
   constructor(config: HonchoMemoryConfig) {
@@ -383,6 +385,26 @@ export class HonchoMemory {
     });
   }
 
+  /**
+   * Set the peers that author the messages.
+   *
+   * The server takes the author of a message as the peer, so the ingestion
+   * cannot say who said what without them.
+   */
+  setPeers(userPeerId: string, assistantPeerId: string): void {
+    this.userPeerId = userPeerId;
+    this.assistantPeerId = assistantPeerId;
+    logServiceEvent({
+      ts: new Date().toISOString(),
+      level: "info",
+      service: "honcho",
+      operation: "peers_set",
+      phase: "completed",
+      userPeerId,
+      assistantPeerId,
+    });
+  }
+
   /**
    * Check if memory is ready
    */
@@ -514,15 +536,28 @@ export class HonchoMemory {
     });
 
     try {
-      // Call Honcho MCP tool through the adapter
+      // The server takes the messages of a session in one call, and the
+      // author of a message is the peer.
       // Use sessionId if available, fall back to workspaceId
       const targetSessionId = this.sessionId ?? this.workspaceId;
-      const result = await this.callHonchoTool("add_message", {
+      const peerId = role === "assistant" ? this.assistantPeerId : this.userPeerId;
+      if (!peerId) {
+        throw new Error("The Honcho peers are not known yet");
+      }
+      const result = await this.callHonchoTool("add_messages_to_session", {
+        workspace_id: this.workspaceId,
         session_id: targetSessionId,
-        role,
-        content: sanitized,
-        message_id: messageId,
-        timestamp: timestamp.toISOString(),
+        messages: [
+          {
+            peer_id: peerId,
+            content: sanitized,
+            metadata: {
+              role,
+              message_id: messageId,
+              timestamp: timestamp.toISOString(),
+            },
+          },
+        ],
       });
 
       if (!result.success) {
@@ -602,27 +637,36 @@ export class HonchoMemory {
     });
 
     try {
-      // Call Honcho get_session_context tool through the adapter
+      // The recall of the server is the search: it answers with the messages
+      // that match the query, and those messages are the context.
       // Use sessionId if available, fall back to workspaceId
       const targetSessionId = this.sessionId ?? this.workspaceId;
-      const result = await this.callHonchoTool("get_context", {
+      const result = await this.callHonchoTool("search", {
+        workspace_id: this.workspaceId,
         session_id: targetSessionId,
         query,
-        limit: 10,
+        message_limit: 10,
       });
 
       if (!result.success) {
         throw new Error(result.error || "Tool call failed");
       }
 
-      // Parse actual response content
+      // Parse the messages the search found.
+      const payload = honchoPayload(result.result);
+      const messages = (payload.parsed as { messages?: unknown } | null)?.messages;
       let context = "";
-      if (result.result && typeof result.result === "object") {
-        const response = result.result as Record<string, unknown>;
-        // Extract context from response based on actual Honcho API shape
-        context = (response.content as string) ||
-                  (response.messages as string[])?.join("\n") ||
-                  JSON.stringify(response);
+      if (Array.isArray(messages)) {
+        context = messages
+          .map((message) => {
+            const text = (message as { content?: unknown })?.content;
+            return typeof text === "string" ? text : "";
+          })
+          .filter((text) => text !== "")
+          .join("\n");
+      }
+      if (context === "" && payload.text !== "") {
+        context = payload.text;
       }
 
       // Apply max context chars limit

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-harness-runtime",
-  "version": "1.1.420",
+  "version": "1.1.422",
   "description": "[BETA] Codex-style /usage status + autonomous coding harness for pi. Not production ready — expect breaking changes.",
   "type": "module",
   "scripts": {
@@ -116,7 +116,7 @@
     "deepagents": "^1.10.5",
     "langchain": "^1.5.10",
     "ws": "^8.22.0",
-    "zod": "^4.5.4"
+    "zod": "^4.6.7"
   },
   "peerDependenciesMeta": {
     "pi-mcp-adapter": {

package/packages/a2a-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/a2a-adapter",
-  "version": "1.1.420",
+  "version": "1.1.422",
   "type": "module",
   "description": "Google Agent-to-Agent (A2A) protocol adapter for pi-harness",
   "main": "dist/index.js",

package/packages/agent-policy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/agent-policy",
-  "version": "1.1.420",
+  "version": "1.1.422",
   "description": "Agent policy runtime for pi-harness - enforces mandatory rule delivery and mutation gating",
   "type": "module",
   "main": "./dist/index.js",

package/packages/architecture-generator/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/architecture-generator",
-  "version": "1.1.420",
+  "version": "1.1.422",
   "description": "Generate ADR and Mermaid diagrams from project analysis",
   "type": "module",
   "main": "./dist/index.js",

package/packages/auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/auth",
-  "version": "1.1.420",
+  "version": "1.1.422",
   "description": "pi-harness-runtime — auth",
   "type": "module",
   "main": "./dist/index.js",

package/packages/autonomous-refactor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/autonomous-refactor",
-  "version": "1.1.420",
+  "version": "1.1.422",
   "type": "module",
   "description": "Autonomous refactoring engine",
   "main": "dist/index.js",

package/packages/autonomous-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/autonomous-runtime",
-  "version": "1.1.420",
+  "version": "1.1.422",
   "description": "Autonomous Operations Runtime — task inbox, lease management, and worker lifecycle (RFC-0101)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/cache-strategy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/cache-strategy",
-  "version": "1.1.420",
+  "version": "1.1.422",
   "type": "module",
   "description": "Smart caching with TTL and invalidation strategies (RFC-0022)",
   "main": "dist/index.js",