@moltzap/client 2026.1002.0 → 2026.1005.0

package/dist/endpoint/mcp/schemas.js

@@ -0,0 +1,89 @@
+/** @file MCP framing of the harness operations: send metadata and JSON Schema projections. */
+import { Effect, JSONSchema, Schema, } from "effect";
+import { harnessAcknowledgeDeliveryRequestSchema, harnessSendArgumentsSchema, harnessSendOptionsSchema, harnessSendResultSchema, inboxRequestSchema, inboxResultSchema, readSendRequestSchema, readSendResultSchema, } from "../../delivery/operations.js";
+import { HARNESS_SEND_META_KEY } from "./names.js";
+const exact = {
+    exact: true,
+    onExcessProperty: "error",
+};
+const exactEmptyObject = Schema.Record({
+    key: Schema.String,
+    value: Schema.Never,
+}).annotations({ parseOptions: exact });
+const harnessEmptyResultSchema = exactEmptyObject;
+const harnessSendMetadataSchema = Schema.Struct({
+    [HARNESS_SEND_META_KEY]: Schema.optionalWith(harnessSendOptionsSchema, {
+        exact: true,
+    }),
+});
+/** JSON Schema for the runtime inbox pagination arguments. */
+export const harnessReadInboxRequestJsonSchema = JSONSchema.make(inboxRequestSchema, { target: "jsonSchema2020-12" });
+/** JSON Schema for classified inbox pages. */
+export const harnessReadInboxResultJsonSchema = JSONSchema.make(inboxResultSchema, { target: "jsonSchema2020-12" });
+/** JSON Schema for keyed send lookup. */
+export const harnessReadSendRequestJsonSchema = JSONSchema.make(readSendRequestSchema, { target: "jsonSchema2020-12" });
+/** JSON Schema for observed send state. */
+export const harnessReadSendResultJsonSchema = JSONSchema.make(readSendResultSchema, { target: "jsonSchema2020-12" });
+/**
+ * Validate semantic arguments separately from runtime-owned send options.
+ * Unrelated SDK metadata belongs to the transport and is not interpreted here.
+ * @param toolArguments Model-visible arguments.
+ * @param metadata The SDK request metadata, if supplied.
+ * @returns One validated invocation for the daemon's existing store.
+ */
+export function decodeHarnessSendCall(toolArguments, metadata) {
+    return Effect.gen(function* () {
+        const args = yield* Schema.decodeUnknown(harnessSendArgumentsSchema)(toolArguments);
+        const runtime = yield* Schema.decodeUnknown(harnessSendMetadataSchema)(metadata === undefined ? {} : metadata);
+        return { ...args, ...runtime[HARNESS_SEND_META_KEY] };
+    }).pipe(Effect.withSpan("decodeHarnessSendCall"));
+}
+/** JSON Schema advertised for the delivery acknowledgment operation. */
+export const harnessAcknowledgeDeliveryRequestJsonSchema = JSONSchema.make(harnessAcknowledgeDeliveryRequestSchema, { target: "jsonSchema2020-12" });
+/** JSON Schema advertised for `send_message` arguments. */
+export const harnessSendArgumentsJsonSchema = JSONSchema.make(harnessSendArgumentsSchema, { target: "jsonSchema2020-12" });
+/** JSON Schema advertised for `send_message` results. */
+export const harnessSendResultJsonSchema = JSONSchema.make(harnessSendResultSchema, { target: "jsonSchema2020-12" });
+/** JSON Schema advertised for empty adapter-operation results. */
+export const harnessEmptyResultJsonSchema = JSONSchema.make(harnessEmptyResultSchema, { target: "jsonSchema2020-12" });
+/** Closed wire failure vocabularies prevent internal diagnostics from escaping. */
+export const harnessFailureReasons = {
+    RUNTIME_READ_REASONS: new Set([
+        "not-registered",
+        "invalid-continuation",
+        "invalid-event",
+        "unknown-event",
+        "persistence-failed",
+    ]),
+    REGISTER_REASONS: new Set([
+        "dependency-unavailable",
+        "persistence-failed",
+        "incompatible-daemon",
+    ]),
+    STATUS_REASONS: new Set(["persistence-failed", "incompatible-daemon"]),
+    SEARCH_AGENTS_REASONS: new Set([
+        "not-registered",
+        "dependency-unavailable",
+        "incompatible-daemon",
+    ]),
+    SEARCH_CONVERSATIONS_REASONS: new Set([
+        "not-registered",
+        "invalid-address",
+        "persistence-failed",
+    ]),
+    READ_CONVERSATION_REASONS: new Set([
+        "not-registered",
+        "invalid-address",
+        "unknown-agent",
+        "invalid-continuation",
+        "history-gap",
+        "persistence-failed",
+    ]),
+    ACKNOWLEDGE_DELIVERY_REASONS: new Set([
+        "unknown-delivery",
+        "delivery-conflict",
+        "persistence-failed",
+        "transport-failed",
+    ]),
+};
+//# sourceMappingURL=schemas.js.map

package/dist/endpoint/mcp/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../../src/endpoint/mcp/schemas.ts"],"names":[],"mappings":"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"}

package/dist/{harness-mcp-wire.d.ts → endpoint/mcp/tools.d.ts}

@@ -1,25 +1,28 @@
 /** @file Official MCP tool catalog and private Harness operation projection. */
-import { type Implementation } from "@modelcontextprotocol/server";
+import { type Implementation, type McpHttpHandler } from "@modelcontextprotocol/server";
 import { Effect } from "effect";
-import type { CollectiveError, SendError } from "./contract.js";
-import type { DeliveryToken } from "./endpoint/store.js";
-import { type HarnessMessageReadyEvent, type HarnessSendRequest, type HarnessSendResult } from "./harness-mcp-contract.js";
-import { type HarnessMcpSubscriptionHandler } from "./harness-mcp-subscription.js";
-import { type ManagementReadConversationRequest, type ManagementReadConversationResult, type ManagementRegisterRequest, type ManagementRegisterResult, type ManagementSearchAgentsRequest, type ManagementSearchAgentsResult, type ManagementSearchConversationsRequest, type ManagementSearchConversationsResult, type ManagementStatusResult } from "./management-runtime.js";
+import { type DeliveryOperations, type EventStore } from "../../delivery/operations.js";
+import { type HarnessMcpCredentials } from "./auth.js";
+import { type ManagementReadConversationRequest, type ManagementReadConversationResult, type ManagementRegisterRequest, type ManagementRegisterResult, type ManagementSearchAgentsRequest, type ManagementSearchAgentsResult, type ManagementSearchConversationsRequest, type ManagementSearchConversationsResult, type ManagementStatusResult } from "./owner-tools.js";
 type ClosedOperationError = Readonly<{
     readonly reason: string;
 }>;
 /** Structural daemon operations projected onto the loopback MCP boundary. */
-export interface HarnessMcpOperations {
+export interface HarnessMcpOperations extends DeliveryOperations {
     readonly readStatus: () => Effect.Effect<ManagementStatusResult, ClosedOperationError>;
     readonly register: (input: ManagementRegisterRequest) => Effect.Effect<ManagementRegisterResult, ClosedOperationError>;
     readonly searchAgents: (input: ManagementSearchAgentsRequest) => Effect.Effect<ManagementSearchAgentsResult, ClosedOperationError>;
     readonly searchConversations: (input: ManagementSearchConversationsRequest) => Effect.Effect<ManagementSearchConversationsResult, ClosedOperationError>;
     readonly readConversation: (input: ManagementReadConversationRequest) => Effect.Effect<ManagementReadConversationResult, ClosedOperationError>;
-    readonly send: (request: HarnessSendRequest) => Effect.Effect<HarnessSendResult, SendError | CollectiveError>;
-    readonly acknowledgeDelivery: (deliveryToken: DeliveryToken) => Effect.Effect<void, ClosedOperationError>;
+}
+/** Official handler with one content-free daemon notification edge. */
+export interface HarnessMcpEventHandler extends McpHttpHandler {
+    readonly hasActiveSubscription: () => boolean;
+    readonly notifyPending: () => boolean;
 }
 interface HarnessMcpHandlerOptions {
+    readonly eventStore?: EventStore;
+    readonly credentials?: HarnessMcpCredentials;
     readonly implementation: Implementation;
     readonly operations: HarnessMcpOperations;
     readonly onSubscriptionActiveChange?: (active: boolean) => void;
@@ -28,10 +31,10 @@ interface HarnessMcpHandlerOptions {
     readonly keepAliveMillis?: number;
 }
 /**
- * Create one state-dependent official MCP handler and message listener.
- * @param options Closed daemon operations and lifecycle callbacks.
- * @returns Handler whose catalog transitions in place after registration.
+ * Create one official MCP handler with explicit event resource ownership.
+ * @param options Daemon operations, optional credentials and callback persistence.
+ * @returns Handler whose catalog changes in place after registration.
  */
-export declare const makeHarnessMcpHttpHandler: (options: HarnessMcpHandlerOptions) => Effect.Effect<HarnessMcpSubscriptionHandler<HarnessMessageReadyEvent>, ClosedOperationError>;
+export declare const makeHarnessMcpHttpHandler: (options: HarnessMcpHandlerOptions) => Effect.Effect<HarnessMcpEventHandler, ClosedOperationError>;
 export {};
-//# sourceMappingURL=harness-mcp-wire.d.ts.map
+//# sourceMappingURL=tools.d.ts.map

package/dist/endpoint/mcp/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/endpoint/mcp/tools.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAEhF,OAAO,EAGL,KAAK,cAAc,EAEnB,KAAK,cAAc,EAKpB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAEL,MAAM,EAQP,MAAM,QAAQ,CAAC;AAGhB,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,UAAU,EAYhB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAEL,KAAK,qBAAqB,EAG3B,MAAM,WAAW,CAAC;AAgBnB,OAAO,EACL,KAAK,iCAAiC,EAEtC,KAAK,gCAAgC,EAErC,KAAK,yBAAyB,EAE9B,KAAK,wBAAwB,EAE7B,KAAK,6BAA6B,EAElC,KAAK,4BAA4B,EAEjC,KAAK,oCAAoC,EAEzC,KAAK,mCAAmC,EAExC,KAAK,sBAAsB,EAE5B,MAAM,kBAAkB,CAAC;AAuB1B,KAAK,oBAAoB,GAAG,QAAQ,CAAC;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAElE,6EAA6E;AAC7E,MAAM,WAAW,oBAAqB,SAAQ,kBAAkB;IAC9D,QAAQ,CAAC,UAAU,EAAE,MAAM,MAAM,CAAC,MAAM,CACtC,sBAAsB,EACtB,oBAAoB,CACrB,CAAC;IACF,QAAQ,CAAC,QAAQ,EAAE,CACjB,KAAK,EAAE,yBAAyB,KAC7B,MAAM,CAAC,MAAM,CAAC,wBAAwB,EAAE,oBAAoB,CAAC,CAAC;IACnE,QAAQ,CAAC,YAAY,EAAE,CACrB,KAAK,EAAE,6BAA6B,KACjC,MAAM,CAAC,MAAM,CAAC,4BAA4B,EAAE,oBAAoB,CAAC,CAAC;IACvE,QAAQ,CAAC,mBAAmB,EAAE,CAC5B,KAAK,EAAE,oCAAoC,KACxC,MAAM,CAAC,MAAM,CAAC,mCAAmC,EAAE,oBAAoB,CAAC,CAAC;IAC9E,QAAQ,CAAC,gBAAgB,EAAE,CACzB,KAAK,EAAE,iCAAiC,KACrC,MAAM,CAAC,MAAM,CAAC,gCAAgC,EAAE,oBAAoB,CAAC,CAAC;CAC5E;AAED,uEAAuE;AACvE,MAAM,WAAW,sBAAuB,SAAQ,cAAc;IAC5D,QAAQ,CAAC,qBAAqB,EAAE,MAAM,OAAO,CAAC;IAC9C,QAAQ,CAAC,aAAa,EAAE,MAAM,OAAO,CAAC;CACvC;AAED,UAAU,wBAAwB;IAChC,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC;IACjC,QAAQ,CAAC,WAAW,CAAC,EAAE,qBAAqB,CAAC;IAC7C,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,oBAAoB,CAAC;IAC1C,QAAQ,CAAC,0BAA0B,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IAChE,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAC1C,wEAAwE;IACxE,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAk6BD;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,YAC3B,wBAAwB,KAChC,MAAM,CAAC,MAAM,CAAC,sBAAsB,EAAE,oBAAoB,CASN,CAAC"}

package/dist/{harness-mcp-wire.js → endpoint/mcp/tools.js}

@@ -1,9 +1,12 @@
 /** @file Official MCP tool catalog and private Harness operation projection. */
 import { createMcpHandler, fromJsonSchema, McpServer, ProtocolError, ProtocolErrorCode, } from "@modelcontextprotocol/server";
-import { Cause, Effect, Exit, JSONSchema, Option, Schema } from "effect";
-import { HARNESS_ACKNOWLEDGE_DELIVERY_TOOL, HARNESS_EVENTS_EXTENSION, HARNESS_SEND_TOOL, harnessAcknowledgeDeliveryRequestJsonSchema, harnessEmptyResultJsonSchema, harnessSendRequestJsonSchema, harnessSendResultJsonSchema, } from "./harness-mcp-contract.js";
-import { makeHarnessMcpSubscriptionHandler, } from "./harness-mcp-subscription.js";
-import { managementReadConversationRequestSchema, managementReadConversationResultSchema, managementRegisterRequestSchema, managementRegisterResultSchema, managementSearchAgentsRequestSchema, managementSearchAgentsResultSchema, managementSearchConversationsRequestSchema, managementSearchConversationsResultSchema, managementStatusResultSchema, } from "./management-runtime.js";
+import { Cause, Effect, Exit, JSONSchema, Layer, Option, Schema, Scope, } from "effect";
+import { decodeHarnessReadSendRequest, readEventRequestSchema, readEventResultSchema, sendErrorData, } from "../../delivery/operations.js";
+import { authenticateHarnessRequest, mayInvokeHarnessTool, } from "./auth.js";
+import { makeHarnessEvents, makeWebhookEvents, runEventOperation, webhookHttpClientLayer, webhookStatusJsonSchema, } from "./events.js";
+import { HARNESS_ACKNOWLEDGE_DELIVERY_TOOL, HARNESS_READ_EVENT_TOOL, HARNESS_READ_INBOX_TOOL, HARNESS_READ_SEND_TOOL, HARNESS_SEND_TOOL, } from "./names.js";
+import { managementReadConversationRequestSchema, managementReadConversationResultSchema, managementRegisterRequestSchema, managementRegisterResultSchema, managementSearchAgentsRequestSchema, managementSearchAgentsResultSchema, managementSearchConversationsRequestSchema, managementSearchConversationsResultSchema, managementStatusResultSchema, } from "./owner-tools.js";
+import { decodeHarnessSendCall, harnessAcknowledgeDeliveryRequestJsonSchema, harnessEmptyResultJsonSchema, harnessFailureReasons, harnessReadInboxRequestJsonSchema, harnessReadInboxResultJsonSchema, harnessReadSendRequestJsonSchema, harnessReadSendResultJsonSchema, harnessSendArgumentsJsonSchema, harnessSendResultJsonSchema, } from "./schemas.js";
 /* eslint-disable agent-code-guard/async-keyword -- Official MCP factories and callbacks are Promise-native. */
 const REGISTER_TOOL = "register";
 const STATUS_TOOL = "status";
@@ -29,40 +32,17 @@ const searchConversationsInput = makeStandardSchema(makeJsonSchema(managementSea
 const searchConversationsOutput = makeStandardSchema(makeJsonSchema(managementSearchConversationsResultSchema));
 const readConversationInput = makeStandardSchema(makeJsonSchema(managementReadConversationRequestSchema));
 const readConversationOutput = makeStandardSchema(makeJsonSchema(managementReadConversationResultSchema));
-const sendInput = makeStandardSchema(harnessSendRequestJsonSchema);
+const sendInput = makeStandardSchema(harnessSendArgumentsJsonSchema);
 const acknowledgeDeliveryInput = makeStandardSchema(harnessAcknowledgeDeliveryRequestJsonSchema);
 const emptyOutput = makeStandardSchema(harnessEmptyResultJsonSchema);
 const sendOutput = makeStandardSchema(harnessSendResultJsonSchema);
-const REGISTER_REASONS = new Set([
-    "dependency-unavailable",
-    "persistence-failed",
-    "incompatible-daemon",
-]);
-const STATUS_REASONS = new Set(["persistence-failed", "incompatible-daemon"]);
-const SEARCH_AGENTS_REASONS = new Set([
-    "not-registered",
-    "dependency-unavailable",
-    "incompatible-daemon",
-]);
-const SEARCH_CONVERSATIONS_REASONS = new Set([
-    "not-registered",
-    "invalid-address",
-    "persistence-failed",
-]);
-const READ_CONVERSATION_REASONS = new Set([
-    "not-registered",
-    "invalid-address",
-    "unknown-agent",
-    "invalid-continuation",
-    "history-gap",
-    "persistence-failed",
-]);
-const ACKNOWLEDGE_DELIVERY_REASONS = new Set([
-    "unknown-delivery",
-    "delivery-conflict",
-    "persistence-failed",
-    "transport-failed",
-]);
+const readEventInput = makeStandardSchema(makeJsonSchema(readEventRequestSchema));
+const readEventOutput = makeStandardSchema(makeJsonSchema(readEventResultSchema));
+const readInboxInput = makeStandardSchema(harnessReadInboxRequestJsonSchema);
+const readInboxOutput = makeStandardSchema(harnessReadInboxResultJsonSchema);
+const readSendInput = makeStandardSchema(harnessReadSendRequestJsonSchema);
+const readSendOutput = makeStandardSchema(harnessReadSendResultJsonSchema);
+const { RUNTIME_READ_REASONS, REGISTER_REASONS, STATUS_REASONS, SEARCH_AGENTS_REASONS, SEARCH_CONVERSATIONS_REASONS, READ_CONVERSATION_REASONS, ACKNOWLEDGE_DELIVERY_REASONS, } = harnessFailureReasons;
 const operationReason = (cause, allowed, fallback) => {
     if (typeof cause !== "object" || cause === null || !("reason" in cause)) {
         return fallback;
@@ -102,27 +82,6 @@ const runOperation = async (options) => {
     }
     return toolResult(outcome.value);
 };
-/**
- * The error data a refused send carries: a collective failure keeps its id
- * and the members or fields it names, so the loopback client rebuilds the
- * same typed error the daemon raised.
- */
-const sendErrorData = (error) => {
-    switch (error._tag) {
-        case "SendError":
-            return { reason: error.reason };
-        case "CollectiveError":
-            return {
-                reason: "collective-failed",
-                id: error.id,
-                failure: error.failure,
-            };
-        default: {
-            const exhaustive = error;
-            return exhaustive;
-        }
-    }
-};
 // #ignore-sloppy-code-next-line[async-keyword]: MCP tool handlers are Promise callbacks, so this edge awaits Effect before returning the SDK result.
 const runSendOperation = async (operation, signal) => {
     const outcome = await Effect.runPromiseExit(operation, { signal });
@@ -182,7 +141,7 @@ const registerRegistrationTool = (server, operations, state) => {
         return result;
     });
 };
-const registerReadTools = (server, operations) => {
+const registerSearchAgentsTool = (server, operations) => {
     server.registerTool(SEARCH_AGENTS_TOOL, { inputSchema: searchAgentsInput, outputSchema: searchAgentsOutput }, (input, context) => runOperation({
         operation: operations.searchAgents(input),
         label: "Agent search",
@@ -190,6 +149,9 @@ const registerReadTools = (server, operations) => {
         fallbackReason: "dependency-unavailable",
         signal: context.mcpReq.signal,
     }));
+};
+const registerReadTools = (server, operations) => {
+    registerSearchAgentsTool(server, operations);
     server.registerTool(SEARCH_CONVERSATIONS_TOOL, {
         inputSchema: searchConversationsInput,
         outputSchema: searchConversationsOutput,
@@ -211,8 +173,44 @@ const registerReadTools = (server, operations) => {
         signal: context.mcpReq.signal,
     }));
 };
+function registerSendTool(server, operations) {
+    server.registerTool(HARNESS_SEND_TOOL, { inputSchema: sendInput, outputSchema: sendOutput }, (input, context) => handleSendToolCall({
+        name: HARNESS_SEND_TOOL,
+        toolArguments: input,
+        metadata: context.mcpReq._meta,
+        signal: context.mcpReq.signal,
+    }, operations));
+}
+const registerEventReadTool = (server, operations) => {
+    server.registerTool(HARNESS_READ_EVENT_TOOL, {
+        description: "Read the original full content of a MoltZap event by eventId. This read has no delivery or acknowledgment side effects.",
+        inputSchema: readEventInput,
+        outputSchema: readEventOutput,
+    }, (input, context) => runOperation({
+        operation: operations.readEvent(input),
+        label: "Event read",
+        allowedReasons: RUNTIME_READ_REASONS,
+        fallbackReason: "persistence-failed",
+        signal: context.mcpReq.signal,
+    }));
+};
 const registerAdapterTools = (server, operations) => {
-    server.registerTool(HARNESS_SEND_TOOL, { inputSchema: sendInput, outputSchema: sendOutput }, (input, context) => runSendOperation(operations.send(input), context.mcpReq.signal));
+    server.registerTool(HARNESS_READ_INBOX_TOOL, { inputSchema: readInboxInput, outputSchema: readInboxOutput }, (input, context) => runOperation({
+        operation: operations.readInbox(input),
+        label: "Inbox read",
+        allowedReasons: RUNTIME_READ_REASONS,
+        fallbackReason: "persistence-failed",
+        signal: context.mcpReq.signal,
+    }));
+    server.registerTool(HARNESS_READ_SEND_TOOL, { inputSchema: readSendInput, outputSchema: readSendOutput }, (input, context) => runOperation({
+        operation: operations.readSend(input),
+        label: "Send lookup",
+        allowedReasons: RUNTIME_READ_REASONS,
+        fallbackReason: "persistence-failed",
+        signal: context.mcpReq.signal,
+    }));
+    registerSendTool(server, operations);
+    registerEventReadTool(server, operations);
     server.registerTool(HARNESS_ACKNOWLEDGE_DELIVERY_TOOL, { inputSchema: acknowledgeDeliveryInput, outputSchema: emptyOutput }, (input, context) => runVoidOperation({
         operation: operations.acknowledgeDelivery(input.deliveryToken),
         label: "Delivery acknowledgment",
@@ -221,7 +219,13 @@ const registerAdapterTools = (server, operations) => {
         signal: context.mcpReq.signal,
     }));
 };
-const registerActiveTools = (server, operations) => {
+const registerActiveTools = (server, operations, role) => {
+    if (role === "runtime") {
+        registerSearchAgentsTool(server, operations);
+        registerSendTool(server, operations);
+        registerEventReadTool(server, operations);
+        return;
+    }
     registerReadTools(server, operations);
     registerAdapterTools(server, operations);
 };
@@ -293,11 +297,14 @@ const handleReadConversationToolCall = async (input, operations) => {
         signal: input.signal,
     });
 };
+const decodeInvocationInput = (input, signal) => runEventOperation(input.pipe(Effect.catchTag("ParseError", () => Effect.fail(new ProtocolError(-32602, "Invalid invocation arguments", {
+    reason: "content-invalid",
+})))), signal);
 // #ignore-sloppy-code-next-line[async-keyword]: The low-level MCP request handler awaits schema validation and the Promise-native operation bridge.
-const handleSendToolCall = async (input, operations) => {
-    const decoded = await decodeToolInput(sendInput, input.toolArguments, input.name);
+async function handleSendToolCall(input, operations) {
+    const decoded = await decodeInvocationInput(decodeHarnessSendCall(input.toolArguments, input.metadata), input.signal);
     return await validateToolOutput(sendOutput, await runSendOperation(operations.send(decoded), input.signal), input.name);
-};
+}
 // #ignore-sloppy-code-next-line[async-keyword]: The low-level MCP request handler awaits schema validation and the Promise-native operation bridge.
 const handleAcknowledgeDeliveryToolCall = async (input, operations) => {
     const decoded = await decodeToolInput(acknowledgeDeliveryInput, input.toolArguments, input.name);
@@ -309,9 +316,43 @@ const handleAcknowledgeDeliveryToolCall = async (input, operations) => {
         signal: input.signal,
     });
 };
+// #ignore-sloppy-code-next-line[async-keyword]: Runtime read dispatch validates the selected MCP schema before invoking the operation.
+const handleInboxReadToolCall = async (input, operations) => {
+    switch (input.name) {
+        case HARNESS_READ_EVENT_TOOL:
+            return await runValidatedOperation(readEventOutput, input.name, {
+                operation: operations.readEvent(await decodeToolInput(readEventInput, input.toolArguments, input.name)),
+                label: "Event read",
+                allowedReasons: RUNTIME_READ_REASONS,
+                fallbackReason: "persistence-failed",
+                signal: input.signal,
+            });
+        case HARNESS_READ_INBOX_TOOL:
+            return await runValidatedOperation(readInboxOutput, input.name, {
+                operation: operations.readInbox(await decodeToolInput(readInboxInput, input.toolArguments, input.name)),
+                label: "Inbox read",
+                allowedReasons: RUNTIME_READ_REASONS,
+                fallbackReason: "persistence-failed",
+                signal: input.signal,
+            });
+        default:
+            return toolNotFound(input.name);
+    }
+};
 // #ignore-sloppy-code-next-line[async-keyword]: Active tool dispatch returns the selected Promise-native MCP operation result.
 const handleActiveToolCall = async (input, operations) => {
+    if ([HARNESS_READ_EVENT_TOOL, HARNESS_READ_INBOX_TOOL].includes(input.name)) {
+        return await handleInboxReadToolCall(input, operations);
+    }
     switch (input.name) {
+        case HARNESS_READ_SEND_TOOL:
+            return await runValidatedOperation(readSendOutput, input.name, {
+                operation: operations.readSend(await decodeInvocationInput(decodeHarnessReadSendRequest(input.toolArguments), input.signal)),
+                label: "Send lookup",
+                allowedReasons: RUNTIME_READ_REASONS,
+                fallbackReason: "persistence-failed",
+                signal: input.signal,
+            });
         case SEARCH_AGENTS_TOOL:
             return await handleSearchAgentsToolCall(input, operations);
         case SEARCH_CONVERSATIONS_TOOL:
@@ -334,7 +375,10 @@ const handleInactiveToolCall = async (input, operations, state) => {
     return await handleRegistrationToolCall(input, operations, state);
 };
 // #ignore-sloppy-code-next-line[async-keyword]: The low-level MCP dispatcher awaits the selected state-dependent Promise callback.
-const handleToolCall = async (input, operations, state) => {
+const handleToolCall = async (input, operations, state, role) => {
+    if (!mayInvokeHarnessTool(role, input.name)) {
+        return toolNotFound(input.name);
+    }
     if (input.name === STATUS_TOOL) {
         return await handleStatusToolCall(input, operations);
     }
@@ -343,61 +387,137 @@ const handleToolCall = async (input, operations, state) => {
     }
     return await handleActiveToolCall(input, operations);
 };
-/**
- * Keep schema and operation failures on the JSON-RPC error channel.
- *
- * The high-level SDK tool dispatcher intentionally converts every thrown tool
- * callback error into an `isError` result. This boundary instead uses the
- * official low-level `tools/call` handler so malformed input and accepted
- * domain failures retain their distinct protocol codes and closed data.
- * @param server Official MCP server that owns the low-level request handler.
- * @param operations Closed daemon operations exposed through the tool catalog.
- * @param state Shared registration state controlling active tool visibility.
- */
-const installToolCallHandler = (server, operations, state) => {
-    server.server.setRequestHandler("tools/call", (request, context) => handleToolCall({
-        name: request.params.name,
-        toolArguments: request.params.arguments ?? {},
-        signal: context.mcpReq.signal,
-    }, operations, state));
+const ownerEventDescriptions = {
+    event_subscription_status: "Inspect the runtime consumer and stalled delivery without exposing callback credentials.",
+    revoke_event_subscription: "Release the active runtime consumer. Pending inbox items remain unread.",
+    resume_event_subscription: "Resume transient callback retries. Terminal rejection requires revocation and reconfiguration.",
+};
+const ownerEventTools = [
+    "event_subscription_status",
+    "revoke_event_subscription",
+    "resume_event_subscription",
+];
+const ownerEventOperation = (events, name) => {
+    switch (name) {
+        case "event_subscription_status":
+            return events.status;
+        case "revoke_event_subscription":
+            return events.revoke.pipe(Effect.as({}));
+        case "resume_event_subscription":
+            return events.resume.pipe(Effect.as({}));
+        default:
+            return undefined;
+    }
+};
+// #ignore-sloppy-code-next-line[async-keyword]: The MCP edge validates its Promise-native tool schema before running the owner operation.
+const handleOwnerOperation = async (operation, input) => {
+    await decodeToolInput(emptyInput, input.toolArguments, input.name);
+    return toolResult(await runEventOperation(operation, input.signal));
 };
-const makeServer = (options, state) => {
-    const server = new McpServer(options.implementation, {
-        capabilities: {
-            experimental: {
-                [HARNESS_EVENTS_EXTENSION]: {},
-            },
-        },
+/** Schema failures and refused operations stay on the JSON-RPC error channel. */
+const installToolCallHandler = (server, operations, state, authority) => {
+    server.server.setRequestHandler("tools/call", (request, context) => {
+        const input = {
+            name: request.params.name,
+            toolArguments: request.params.arguments ?? {},
+            metadata: context.mcpReq._meta,
+            signal: context.mcpReq.signal,
+        };
+        const ownerOperation = ownerEventOperation(authority.events, input.name);
+        if (authority.role === "owner" && ownerOperation !== undefined) {
+            return handleOwnerOperation(ownerOperation, input);
+        }
+        return handleToolCall(input, operations, state, authority.role);
     });
-    registerStatusTool(server, options.operations);
+};
+const registerOwnerEvents = (server) => {
+    for (const name of ownerEventTools) {
+        server.registerTool(name, {
+            description: ownerEventDescriptions[name],
+            inputSchema: emptyInput,
+            ...(name === "event_subscription_status"
+                ? { outputSchema: makeStandardSchema(webhookStatusJsonSchema) }
+                : {}),
+        }, () => toolResult({}));
+    }
+};
+const runtimeOperations = (operations, events) => ({
+    ...operations,
+    acknowledgeDelivery: (token) => operations
+        .acknowledgeDelivery(token)
+        .pipe(Effect.tap(() => Effect.sync(() => events.notifyPending()))),
+});
+const makeServer = (options, state, events, role) => {
+    const capabilities = { tools: {}, events: {} };
+    const server = new McpServer(options.implementation, { capabilities });
+    if (role !== "runtime") {
+        registerStatusTool(server, options.operations);
+    }
+    if (role === "owner") {
+        registerOwnerEvents(server);
+    }
     if (state.active) {
-        registerActiveTools(server, options.operations);
+        registerActiveTools(server, options.operations, role);
     }
-    else {
+    else if (role !== "runtime") {
         registerRegistrationTool(server, options.operations, state);
     }
-    installToolCallHandler(server, options.operations, state);
+    installToolCallHandler(server, runtimeOperations(options.operations, events), state, { role, events });
+    events.install(server.server, role === "local" ? undefined : role);
     return server;
 };
-/**
- * Create one state-dependent official MCP handler and message listener.
- * @param options Closed daemon operations and lifecycle callbacks.
- * @returns Handler whose catalog transitions in place after registration.
- */
-export const makeHarnessMcpHttpHandler = (options) => options.operations.readStatus().pipe(Effect.map((status) => {
-    const state = { active: status.kind === "active" };
-    const delegate = createMcpHandler(() => makeServer(options, state), {
-        legacy: "reject",
-        responseMode: "json",
-        onerror: options.onerror,
-    });
-    return makeHarnessMcpSubscriptionHandler({
-        delegate,
-        implementation: options.implementation,
-        onActiveChange: options.onSubscriptionActiveChange,
-        onerror: options.onerror,
+const officialHandler = (options, state, events) => createMcpHandler((context) => {
+    const request = context.requestInfo;
+    if (request === undefined) {
+        throw new ProtocolError(-32012, "Authentication required");
+    }
+    const role = authenticateHarnessRequest(request, options.credentials);
+    if (role === undefined) {
+        throw new ProtocolError(-32012, "Authentication required");
+    }
+    return makeServer(options, state, events, role);
+}, { legacy: "reject", responseMode: "auto", onerror: options.onerror });
+const guardedHandler = (options, delegate, events, scope) => ({
+    ...delegate,
+    hasActiveSubscription: events.hasActiveSubscription,
+    notifyPending: events.notifyPending,
+    fetch: (request, requestOptions) => authenticateHarnessRequest(request, options.credentials) === undefined
+        ? Promise.resolve(new Response("Unauthorized", {
+            status: 401,
+            headers: { "www-authenticate": "Bearer" },
+        }))
+        : delegate.fetch(request, requestOptions),
+    close: () => Effect.runPromise(events.close.pipe(Effect.ensuring(Effect.tryPromise(() => delegate.close()).pipe(Effect.ignore)), Effect.ensuring(Scope.close(scope, Exit.void)))),
+});
+const acquireWebhook = (options, scope, gate) => Effect.gen(function* () {
+    if (options.credentials === undefined || options.eventStore === undefined) {
+        return undefined;
+    }
+    const context = yield* Layer.buildWithScope(webhookHttpClientLayer, scope);
+    return yield* makeWebhookEvents(options.eventStore, gate).pipe(Effect.provide(context), Effect.mapError(() => ({ reason: "persistence-failed" })));
+});
+const acquireHandler = (options, state, scope) => Effect.gen(function* () {
+    const gate = yield* Effect.makeSemaphore(1);
+    const webhook = yield* acquireWebhook(options, scope, gate);
+    const events = yield* makeHarnessEvents({
+        ...(webhook === undefined ? {} : { webhook }),
+        summary: options.operations.readInboxSummary,
+        registered: () => state.active,
+        gate,
         keepAliveMillis: options.keepAliveMillis,
+        onActiveChange: options.onSubscriptionActiveChange,
     });
-}));
+    return guardedHandler(options, officialHandler(options, state, events), events, scope);
+});
+/**
+ * Create one official MCP handler with explicit event resource ownership.
+ * @param options Daemon operations, optional credentials and callback persistence.
+ * @returns Handler whose catalog changes in place after registration.
+ */
+export const makeHarnessMcpHttpHandler = (options) => Effect.gen(function* () {
+    const status = yield* options.operations.readStatus();
+    const scope = yield* Scope.make();
+    return yield* acquireHandler(options, { active: status.kind === "active" }, scope).pipe(Effect.onError(() => Scope.close(scope, Exit.void)));
+}).pipe(Effect.withSpan("makeHarnessMcpHttpHandler"));
 /* eslint-enable agent-code-guard/async-keyword -- Restore repository defaults after the MCP boundary. */
-//# sourceMappingURL=harness-mcp-wire.js.map
+//# sourceMappingURL=tools.js.map