@masons/agent-network 0.4.16 → 0.4.18

package/dist/conversation-manager.js

@@ -2,40 +2,57 @@
  * Conversation Manager — maps contacts to conversations.
  *
  * Owns the identity-based API that the Tool Interface and Inbound Dispatcher
- * call. Internally delegates session management to SessionLifecycle.
+ * call. Sends messages directly to routable addresses via ConnectorClient.send().
  *
- * Contact resolution: handle -> `mstps://${connectorHost}/${handle}`
- * Internal key: MSTP address (same as SessionLifecycle).
- * One session per contact, last-write-wins (D2).
- * In-memory only, no persistence (D3).
+ * Contact resolution: handle → `mstps://${connectorHost}/${handle}`
+ * Address schemes: MSTP (`mstps://`), handle (bare), passport (`passport:@`)
+ * Internal key: routable address.
+ * One conversation per contact, in-memory only (D3).
  *
- * @see docs/openclaw/session-abstraction-system-design.md §4.1
+ * @see docs/connector/gateway-v2-consumer-adaptation-plan.md PR 2
  */
 import createDebug from "debug";
-import { SessionLifecycle } from "./session-lifecycle.js";
+import { ConnectorError } from "./connector-client.js";
+import { extractHandleFromAddress } from "./handle-utils.js";
 const dbg = createDebug("agent-network:conversation-manager");
 // ---------------------------------------------------------------------------
+// Error code → tool result mapping
+// ---------------------------------------------------------------------------
+const ERROR_MESSAGES = {
+    ADDRESS_NOT_FOUND: "Cannot find agent '{to}'. Check the handle.",
+    ACCESS_DENIED: "No connection to '{to}'. Send a connection request first.",
+    RECIPIENT_UNREACHABLE: "Agent '{to}' is currently unreachable. Try again later.",
+    MAILBOX_FULL: "Agent '{to}' mailbox is full. Try again later.",
+    INTERNAL_ERROR: "Network error. Try again.",
+};
+function formatErrorMessage(code, to) {
+    const template = ERROR_MESSAGES[code] ?? `Send failed: ${code}`;
+    return to ? template.replace(/\{to\}/g, to) : template;
+}
+// ---------------------------------------------------------------------------
 // ConversationManager
 // ---------------------------------------------------------------------------
 export class ConversationManager {
-    sessionLifecycle;
     client;
     connectorHost;
-    /** Conversations keyed by MSTP address */
+    /** Conversations keyed by routable address */
     conversations = new Map();
     constructor(client, connectorHost) {
         this.client = client;
         this.connectorHost = connectorHost;
-        this.sessionLifecycle = new SessionLifecycle(client);
     }
     // -------------------------------------------------------------------------
     // Public API — identity-based
     // -------------------------------------------------------------------------
     /**
-     * Send a message to a contact. Session management is transparent.
-     * Creates a session automatically if none exists (D1 — sync-but-transparent).
+     * Send a message to a contact. Sends directly to the resolved address —
+     * no session management needed.
      *
-     * @param contact - Handle or MSTP address of the target agent.
+     * Returns a structured result with status and optional error.
+     * ConnectorError codes (ADDRESS_NOT_FOUND, ACCESS_DENIED, etc.) are
+     * mapped to human-readable messages for LLM tool results.
+     *
+     * @param contact - Handle, MSTP address, or passport address of the target.
      * @param content - Message content to send.
      */
     async send(contact, content) {
@@ -50,81 +67,62 @@ export class ConversationManager {
             });
         }
         try {
-            const sessionId = await this.sessionLifecycle.ensureSession(address);
-            const sent = this.client.sendMessage(sessionId, content, {
-                contentType: "text",
-            });
-            if (!sent) {
-                return {
-                    status: "failed",
-                    error: "Failed to send message. The network connection may be temporarily unavailable.",
-                };
-            }
+            const ack = await this.client.send(address, content, "text");
             // Update lastMessageAt
             const entry = this.conversations.get(address);
             if (entry) {
                 entry.lastMessageAt = Date.now();
             }
-            dbg("send contact=%s address=%s sessionId=%s", contact, address, sessionId);
+            dbg("send contact=%s address=%s status=%s", contact, address, ack.status);
             return { status: "sent" };
         }
         catch (err) {
+            if (err instanceof ConnectorError) {
+                const message = formatErrorMessage(err.code, err.to ?? contact);
+                dbg("send failed contact=%s code=%s message=%s", contact, err.code, message);
+                return { status: "failed", error: message, errorCode: err.code };
+            }
             const message = err instanceof Error ? err.message : "Unknown error";
             dbg("send failed contact=%s error=%s", contact, message);
             return { status: "failed", error: message };
         }
     }
     /**
-     * Register an inbound session (remote agent initiated).
-     * Called by the channel adapter on SESSION_CREATED with direction=inbound.
+     * Register an inbound conversation (remote agent or visitor initiated).
+     * Called by the channel adapter when a message arrives from a new address.
      */
-    registerInbound(sessionId, contact, address) {
-        this.sessionLifecycle.registerInbound(sessionId, address);
-        if (!this.conversations.has(address)) {
-            this.conversations.set(address, {
-                contact,
-                address,
-                lastMessageAt: Date.now(),
-                initiatedBy: "remote",
-            });
-        }
-        else {
-            const entry = this.conversations.get(address);
-            if (entry) {
-                entry.lastMessageAt = Date.now();
-            }
-        }
-        dbg("registerInbound sessionId=%s contact=%s address=%s", sessionId, contact, address);
+    registerInbound(contact, address) {
+        this.ensureConversationEntry(contact, address, "remote");
+        dbg("registerInbound contact=%s address=%s", contact, address);
     }
     /**
-     * Resolve a sessionId to a contact handle.
-     * Used by the inbound dispatcher to derive sender identity from a message event.
+     * Resolve a routable address to a contact handle.
+     * Used by the inbound dispatcher to derive sender identity from MESSAGE_RECEIVED.from.
      */
-    getContactBySessionId(sessionId) {
-        const address = this.sessionLifecycle.getAddressBySessionId(sessionId);
-        if (!address)
-            return undefined;
+    getContactByAddress(address) {
         const entry = this.conversations.get(address);
-        return entry?.contact;
-    }
-    /**
-     * Resolve a sessionId to an MSTP address.
-     * Used by the channel adapter for reverse lookup.
-     */
-    getAddressBySessionId(sessionId) {
-        return this.sessionLifecycle.getAddressBySessionId(sessionId);
+        if (entry)
+            return entry.contact;
+        // Try resolving — the address might be a full MSTP address while conversations
+        // are keyed by a different form. Extract handle as fallback.
+        for (const [, e] of this.conversations) {
+            if (e.address === address)
+                return e.contact;
+        }
+        return undefined;
     }
     /**
      * List all conversations with metadata.
+     * `active` is always true for address-based protocol — there is no session
+     * lifecycle. Conversations persist until explicitly ended or Plugin restarts.
      */
     listConversations() {
         const result = [];
-        for (const [address, entry] of this.conversations) {
-            const sessionId = this.sessionLifecycle.getSession(address);
+        for (const [, entry] of this.conversations) {
             result.push({
                 contact: entry.contact,
                 address: entry.address,
-                active: sessionId !== null,
+                active: true,
                 lastMessageAt: entry.lastMessageAt,
                 initiatedBy: entry.initiatedBy,
             });
@@ -144,50 +142,76 @@ export class ConversationManager {
     }
     /**
      * End the conversation with a contact.
-     * Closes the active session if one exists.
+     * Removes the conversation entry. No END_SESSION needed — the Connector
+     * manages connection lifecycle (idle timeout).
      */
     endConversation(contact) {
         const address = this.resolveAddress(contact);
-        this.sessionLifecycle.closeSession(address);
         this.conversations.delete(address);
         dbg("endConversation contact=%s address=%s", contact, address);
     }
-    // NOTE: handleDisconnected() and handleSessionEnded() are NOT needed here.
-    // SessionLifecycle owns session state transitions via its own event subscriptions
-    // (session_ended, disconnected). Conversations persist across both events —
-    // sessions are recreated transparently on the next send().
     // -------------------------------------------------------------------------
     // Contact resolution
     // -------------------------------------------------------------------------
     /**
-     * Resolve a contact (handle or MSTP address) to an MSTP address.
+     * Resolve a contact (handle, MSTP address, or passport address) to a
+     * routable address.
      *
      * Resolution order:
-     * 1. If `contact` is already an MSTP address (starts with mstps:// or mstp://),
-     *    return it as-is.
-     * 2. If `contact` is already a key in the conversations map (e.g., a sessionId
-     *    used as fallback address for direct MSTP clients), return it as-is.
-     * 3. Otherwise construct: `mstps://${connectorHost}/${handle}`.
+     * 1. MSTP address (starts with mstps:// or mstp://) → return as-is.
+     * 2. Passport address (starts with passport:) → return as-is (already routable).
+     * 3. Already a key in the conversations map → return as-is.
+     * 4. Reverse lookup: if any existing conversation has this handle as its
+     *    contact, use that conversation's address. This ensures replies to a
+     *    cross-Connector sender route to the sender's original address, not to
+     *    a locally-constructed address.
+     * 5. Otherwise treat as handle → construct `mstps://${connectorHost}/${handle}`.
      */
     resolveAddress(contact) {
         if (contact.startsWith("mstps://") || contact.startsWith("mstp://")) {
             return contact;
         }
-        // Check if the contact string is already a registered conversation key
-        // (handles the fallback case where sessionId is used as address).
+        if (contact.startsWith("passport:")) {
+            return contact;
+        }
         if (this.conversations.has(contact)) {
             return contact;
         }
+        // Reverse lookup: handle → existing conversation address.
+        // Handles the case where inbound arrived from a remote Connector
+        // (e.g., "mstps://remote-host/mason") but the LLM replies using
+        // the bare handle "mason".
+        for (const [addr, entry] of this.conversations) {
+            if (entry.contact === contact)
+                return addr;
+        }
         return `mstps://${this.connectorHost}/${contact}`;
     }
     /**
-     * Extract handle from an MSTP address.
-     * `mstps://preview.masons.ai/alice` -> `alice`
+     * Extract a display-friendly handle from any address scheme.
+     * Delegates to shared utility — single source of truth.
      */
     extractHandle(address) {
-        const trimmed = address.replace(/\/+$/, "");
-        const parts = trimmed.split("/");
-        return parts[parts.length - 1] || address;
+        return extractHandleFromAddress(address);
+    }
+    // -------------------------------------------------------------------------
+    // Internal
+    // -------------------------------------------------------------------------
+    ensureConversationEntry(contact, address, initiatedBy) {
+        if (!this.conversations.has(address)) {
+            this.conversations.set(address, {
+                contact,
+                address,
+                lastMessageAt: Date.now(),
+                initiatedBy,
+            });
+        }
+        else {
+            const entry = this.conversations.get(address);
+            if (entry) {
+                entry.lastMessageAt = Date.now();
+            }
+        }
     }
     // -------------------------------------------------------------------------
     // Test helpers
@@ -195,6 +219,5 @@ export class ConversationManager {
     /** @internal Reset for test isolation. */
     _resetForTesting() {
         this.conversations.clear();
-        this.sessionLifecycle._resetForTesting();
     }
 }

package/dist/environment-context.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Agent Environment Context — self-identity and owner identity.
+ *
+ * Populated from REGISTER_ACK when the Connector includes agent/owner fields
+ * (#969). Connection-scoped: cleared on disconnect, refreshed on reconnect.
+ *
+ * Module-level singleton — shared between connector-client.ts (write) and
+ * plugin.ts (read). Follows the same pattern as owner-session-state.ts.
+ *
+ * **Trust model**: Identity is Connector-asserted, not cryptographically
+ * verified. The Plugin trusts the Connector because they communicate over an
+ * authenticated WebSocket channel. A self-hosted Connector could assert
+ * arbitrary identity — this is the same trust level as the `from` field on
+ * MESSAGE_RECEIVED. Do not build security-critical logic on these values.
+ */
+export interface AgentIdentity {
+    handle: string;
+    name?: string;
+}
+export interface OwnerIdentity {
+    handle: string;
+    displayName?: string;
+}
+/**
+ * Store agent and owner identity from an enriched REGISTER_ACK.
+ *
+ * Either parameter may be undefined (old Connector, or agent without
+ * a bound owner). Undefined values leave the corresponding state as null.
+ */
+export declare function setEnvironmentContext(agent?: {
+    handle: string;
+    name?: string;
+}, owner?: {
+    handle: string;
+    displayName?: string;
+}): void;
+export declare function getAgentIdentity(): AgentIdentity | null;
+export declare function getOwnerIdentity(): OwnerIdentity | null;
+/** Convenience: get the owner's handle for interaction tagging. */
+export declare function getOwnerHandle(): string | null;
+/** Clear all environment context (connection lost — identity invalid). */
+export declare function clearEnvironmentContext(): void;
+/** @internal Reset module state for test isolation. */
+export declare function _resetForTesting(): void;
+//# sourceMappingURL=environment-context.d.ts.map

package/dist/environment-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment-context.d.ts","sourceRoot":"","sources":["../src/environment-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAaD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,CAAC,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EACzC,KAAK,CAAC,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/C,IAAI,CAkBN;AAMD,wBAAgB,gBAAgB,IAAI,aAAa,GAAG,IAAI,CAEvD;AAED,wBAAgB,gBAAgB,IAAI,aAAa,GAAG,IAAI,CAEvD;AAED,mEAAmE;AACnE,wBAAgB,cAAc,IAAI,MAAM,GAAG,IAAI,CAE9C;AAMD,0EAA0E;AAC1E,wBAAgB,uBAAuB,IAAI,IAAI,CAG9C;AAMD,uDAAuD;AACvD,wBAAgB,gBAAgB,IAAI,IAAI,CAGvC"}

package/dist/environment-context.js

@@ -0,0 +1,81 @@
+/**
+ * Agent Environment Context — self-identity and owner identity.
+ *
+ * Populated from REGISTER_ACK when the Connector includes agent/owner fields
+ * (#969). Connection-scoped: cleared on disconnect, refreshed on reconnect.
+ *
+ * Module-level singleton — shared between connector-client.ts (write) and
+ * plugin.ts (read). Follows the same pattern as owner-session-state.ts.
+ *
+ * **Trust model**: Identity is Connector-asserted, not cryptographically
+ * verified. The Plugin trusts the Connector because they communicate over an
+ * authenticated WebSocket channel. A self-hosted Connector could assert
+ * arbitrary identity — this is the same trust level as the `from` field on
+ * MESSAGE_RECEIVED. Do not build security-critical logic on these values.
+ */
+// ---------------------------------------------------------------------------
+// State
+// ---------------------------------------------------------------------------
+let agentIdentity = null;
+let ownerIdentity = null;
+// ---------------------------------------------------------------------------
+// Write API (called from connector-client.ts on REGISTER_ACK)
+// ---------------------------------------------------------------------------
+/**
+ * Store agent and owner identity from an enriched REGISTER_ACK.
+ *
+ * Either parameter may be undefined (old Connector, or agent without
+ * a bound owner). Undefined values leave the corresponding state as null.
+ */
+export function setEnvironmentContext(agent, owner) {
+    // Defensive: validate handle is a string even though types say so.
+    // A malformed REGISTER_ACK from an untrusted Connector could send
+    // non-string values; guard prevents storing garbage in module state.
+    if (agent && typeof agent.handle === "string") {
+        const identity = { handle: agent.handle };
+        if (agent.name)
+            identity.name = agent.name;
+        agentIdentity = identity;
+    }
+    else {
+        agentIdentity = null;
+    }
+    if (owner && typeof owner.handle === "string") {
+        const identity = { handle: owner.handle };
+        if (owner.displayName)
+            identity.displayName = owner.displayName;
+        ownerIdentity = identity;
+    }
+    else {
+        ownerIdentity = null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Read API (called from plugin.ts in before_prompt_build)
+// ---------------------------------------------------------------------------
+export function getAgentIdentity() {
+    return agentIdentity;
+}
+export function getOwnerIdentity() {
+    return ownerIdentity;
+}
+/** Convenience: get the owner's handle for interaction tagging. */
+export function getOwnerHandle() {
+    return ownerIdentity?.handle ?? null;
+}
+// ---------------------------------------------------------------------------
+// Lifecycle
+// ---------------------------------------------------------------------------
+/** Clear all environment context (connection lost — identity invalid). */
+export function clearEnvironmentContext() {
+    agentIdentity = null;
+    ownerIdentity = null;
+}
+// ---------------------------------------------------------------------------
+// Test-only reset
+// ---------------------------------------------------------------------------
+/** @internal Reset module state for test isolation. */
+export function _resetForTesting() {
+    agentIdentity = null;
+    ownerIdentity = null;
+}

package/dist/handle-utils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared handle extraction utility.
+ *
+ * Used by ConversationManager (contact resolution) and Channel (sender name derivation).
+ * Single source of truth for address → display handle mapping.
+ */
+/**
+ * Extract a display-friendly handle from any address scheme.
+ *
+ * - `mstps://preview.masons.ai/alice` → `alice`
+ * - `passport:@luomingke` → `luomingke`
+ * - `passport:user_abc` → `user_abc`
+ * - `mason` → `mason` (bare handle passthrough)
+ */
+export declare function extractHandleFromAddress(address: string): string;
+//# sourceMappingURL=handle-utils.d.ts.map

package/dist/handle-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-utils.d.ts","sourceRoot":"","sources":["../src/handle-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAUhE"}

package/dist/handle-utils.js

@@ -0,0 +1,25 @@
+/**
+ * Shared handle extraction utility.
+ *
+ * Used by ConversationManager (contact resolution) and Channel (sender name derivation).
+ * Single source of truth for address → display handle mapping.
+ */
+/**
+ * Extract a display-friendly handle from any address scheme.
+ *
+ * - `mstps://preview.masons.ai/alice` → `alice`
+ * - `passport:@luomingke` → `luomingke`
+ * - `passport:user_abc` → `user_abc`
+ * - `mason` → `mason` (bare handle passthrough)
+ */
+export function extractHandleFromAddress(address) {
+    if (address.startsWith("passport:@")) {
+        return address.slice("passport:@".length);
+    }
+    if (address.startsWith("passport:")) {
+        return address.slice("passport:".length);
+    }
+    const trimmed = address.replace(/\/+$/, "");
+    const parts = trimmed.split("/");
+    return parts[parts.length - 1] || address;
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { AUTHORIZED_TOKEN_TTL_MS, SETUP_CODE_CHARSET, SETUP_CODE_LENGTH, SETUP_CODE_TTL_MS, } from "./constants.js";
 export type { AgentNetworkAccount } from "./config-schema.js";
-export type { ErrorEvent, MessageReceivedEvent, RegisterAckEvent, SessionCreatedEvent, SessionEndedEvent, } from "./types.js";
+export type { AddressedMessageEvent, DeliveryPendingEvent, RegisterAckEvent, SendAckEvent, StructuredErrorEvent, } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,uBAAuB,EACvB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AAIxB,YAAY,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,YAAY,EACV,UAAU,EACV,oBAAoB,EACpB,gBAAgB,EAChB,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,uBAAuB,EACvB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AAIxB,YAAY,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,YAAY,EACV,qBAAqB,EACrB,oBAAoB,EACpB,gBAAgB,EAChB,YAAY,EACZ,oBAAoB,GACrB,MAAM,YAAY,CAAC"}

package/dist/owner-session-state.d.ts

@@ -1,31 +1,24 @@
 /**
- * Owner Session State — tracks which MSTP sessions belong to the agent's owner.
+ * Owner Identity State — tracks which addresses belong to the agent's owner.
  *
  * When the Connector detects that a Passport visitor is the agent's owner
- * (deterministic userId comparison, #836), it sets `is_owner: true` in the
- * SESSION_CREATED metadata. This module maintains the Plugin-side state:
+ * (deterministic userId comparison, #836), it includes `is_owner: true` in
+ * MESSAGE_RECEIVED metadata. This module maintains the Plugin-side state:
  *
- * - `ownerSessionIds`: Set of session IDs where the visitor is the owner.
- *   Populated on session_created, cleaned up on session_ended / disconnected.
+ * - `ownerAddresses`: Set of routable addresses where the visitor is the owner.
+ *   Populated on first MESSAGE_RECEIVED with is_owner=true, cleared on disconnect.
  *
  * - `currentTurnIsOwner`: Per-turn flag set in the message_received handler
  *   and read in before_prompt_build. Reset after each read to avoid stale state.
- *   Race condition note (from design review): if two messages arrive on
- *   different sessions concurrently, the flag may reflect the wrong session.
- *   Fail-safe: owner gets the routing warning (same as today's behavior).
- *   Acceptable for Phase 1 — OpenClaw processes turns sequentially per agent.
  *
  * Module-level singleton — shared between channel.ts (write) and plugin.ts (read).
- * Same pattern as owner-notes.ts.
  */
-/** Mark a session as belonging to the owner. */
-export declare function markOwnerSession(sessionId: string): void;
-/** Remove a session from owner tracking (session ended or disconnected). */
-export declare function removeOwnerSession(sessionId: string): void;
-/** Clear all owner sessions (connection lost — all sessions are invalid). */
-export declare function clearOwnerSessions(): void;
-/** Check if a session belongs to the owner. */
-export declare function isOwnerSession(sessionId: string): boolean;
+/** Mark an address as belonging to the owner. */
+export declare function markOwnerAddress(address: string): void;
+/** Check if an address belongs to the owner. */
+export declare function isOwnerAddress(address: string): boolean;
+/** Clear all owner state (connection lost — all addresses invalid). */
+export declare function clearOwnerState(): void;
 /**
  * Set the per-turn owner flag. Called in message_received before dispatch.
  * The flag is consumed (read + reset) by before_prompt_build.

package/dist/owner-session-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"owner-session-state.d.ts","sourceRoot":"","sources":["../src/owner-session-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAgBH,gDAAgD;AAChD,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAExD;AAED,4EAA4E;AAC5E,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAE1D;AAED,6EAA6E;AAC7E,wBAAgB,kBAAkB,IAAI,IAAI,CAGzC;AAED,+CAA+C;AAC/C,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAE1D;AAMD;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAInD"}
+{"version":3,"file":"owner-session-state.d.ts","sourceRoot":"","sources":["../src/owner-session-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAgBH,iDAAiD;AACjD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAEtD;AAED,gDAAgD;AAChD,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,uEAAuE;AACvE,wBAAgB,eAAe,IAAI,IAAI,CAGtC;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAE1D;AAMD;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAInD"}

package/dist/owner-session-state.js

@@ -1,50 +1,41 @@
 /**
- * Owner Session State — tracks which MSTP sessions belong to the agent's owner.
+ * Owner Identity State — tracks which addresses belong to the agent's owner.
  *
  * When the Connector detects that a Passport visitor is the agent's owner
- * (deterministic userId comparison, #836), it sets `is_owner: true` in the
- * SESSION_CREATED metadata. This module maintains the Plugin-side state:
+ * (deterministic userId comparison, #836), it includes `is_owner: true` in
+ * MESSAGE_RECEIVED metadata. This module maintains the Plugin-side state:
  *
- * - `ownerSessionIds`: Set of session IDs where the visitor is the owner.
- *   Populated on session_created, cleaned up on session_ended / disconnected.
+ * - `ownerAddresses`: Set of routable addresses where the visitor is the owner.
+ *   Populated on first MESSAGE_RECEIVED with is_owner=true, cleared on disconnect.
  *
  * - `currentTurnIsOwner`: Per-turn flag set in the message_received handler
  *   and read in before_prompt_build. Reset after each read to avoid stale state.
- *   Race condition note (from design review): if two messages arrive on
- *   different sessions concurrently, the flag may reflect the wrong session.
- *   Fail-safe: owner gets the routing warning (same as today's behavior).
- *   Acceptable for Phase 1 — OpenClaw processes turns sequentially per agent.
  *
  * Module-level singleton — shared between channel.ts (write) and plugin.ts (read).
- * Same pattern as owner-notes.ts.
  */
 // ---------------------------------------------------------------------------
 // State
 // ---------------------------------------------------------------------------
-/** Session IDs where the visitor has been identified as the agent's owner. */
-const ownerSessionIds = new Set();
-/** Whether the current LLM turn was triggered by an owner session. */
+/** Routable addresses where the visitor has been identified as the owner. */
+const ownerAddresses = new Set();
+/** Whether the current LLM turn was triggered by an owner. */
 let currentTurnIsOwner = false;
 // ---------------------------------------------------------------------------
 // Write API (called from channel.ts)
 // ---------------------------------------------------------------------------
-/** Mark a session as belonging to the owner. */
-export function markOwnerSession(sessionId) {
-    ownerSessionIds.add(sessionId);
+/** Mark an address as belonging to the owner. */
+export function markOwnerAddress(address) {
+    ownerAddresses.add(address);
 }
-/** Remove a session from owner tracking (session ended or disconnected). */
-export function removeOwnerSession(sessionId) {
-    ownerSessionIds.delete(sessionId);
+/** Check if an address belongs to the owner. */
+export function isOwnerAddress(address) {
+    return ownerAddresses.has(address);
 }
-/** Clear all owner sessions (connection lost — all sessions are invalid). */
-export function clearOwnerSessions() {
-    ownerSessionIds.clear();
+/** Clear all owner state (connection lost — all addresses invalid). */
+export function clearOwnerState() {
+    ownerAddresses.clear();
     currentTurnIsOwner = false;
 }
-/** Check if a session belongs to the owner. */
-export function isOwnerSession(sessionId) {
-    return ownerSessionIds.has(sessionId);
-}
 /**
  * Set the per-turn owner flag. Called in message_received before dispatch.
  * The flag is consumed (read + reset) by before_prompt_build.

package/dist/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAoHA,UAAU,iBAAiB;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,eAAe,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IACjD,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IACjE,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,GAAG,IAAI,CAAC;CACnE;AAED,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;kBA4BI,iBAAiB;CAgThC,CAAC;AAEF,eAAe,MAAM,CAAC"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AA8HA,UAAU,iBAAiB;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,eAAe,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IACjD,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IACjE,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,GAAG,IAAI,CAAC;CACnE;AAED,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;kBA4BI,iBAAiB;CA6UhC,CAAC;AAEF,eAAe,MAAM,CAAC"}