web-agent-bridge 2.3.0 → 2.3.1

package/public/script/wab.min.js

@@ -358,63 +358,128 @@
 
   // ── Agent Mesh Protocol ───────────────────────────────────────────
 
+  function _meshReq(url, opts) {
+    return fetch(url, opts).then(function(r) {
+      if (!r.ok) return r.json().catch(function() { return {}; }).then(function(e) { return Promise.reject(new Error(e.error || r.statusText)); });
+      return r.json();
+    });
+  }
+
   WABInstance.prototype.meshJoin = function(role, displayName, capabilities) {
-    if (!this.serverUrl) return Promise.resolve({ error: 'Mesh requires a server URL' });
+    if (!this.serverUrl) return Promise.reject(new Error('Mesh requires a server URL'));
     var self = this;
-    return fetch(this.serverUrl + '/api/mesh/agents', {
+    return _meshReq(this.serverUrl + '/api/mesh/agents', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ siteId: this.name, role: role, displayName: displayName, capabilities: capabilities })
-    }).then(function(r) { return r.json(); }).then(function(data) {
-      self._meshAgentId = data.id;
-      self._emit('mesh:joined', data);
-      return data;
+    }).then(function(data) {
+      self._meshAgentId = data.agent.id;
+      self._meshHeartbeat = setInterval(function() {
+        _meshReq(self.serverUrl + '/api/mesh/agents/' + self._meshAgentId + '/heartbeat', { method: 'POST' }).catch(function() {});
+      }, 30000);
+      self._emit('mesh:joined', data.agent);
+      return data.agent;
     });
   };
 
+  WABInstance.prototype.meshLeave = function() {
+    if (this._meshHeartbeat) { clearInterval(this._meshHeartbeat); this._meshHeartbeat = null; }
+    if (!this.serverUrl || !this._meshAgentId) return Promise.resolve();
+    var self = this;
+    return _meshReq(this.serverUrl + '/api/mesh/agents/' + this._meshAgentId, { method: 'DELETE' })
+      .catch(function() {}).then(function() { self._meshAgentId = null; });
+  };
+
   WABInstance.prototype.meshPublish = function(channel, messageType, subject, payload, opts) {
-    if (!this.serverUrl || !this._meshAgentId) return Promise.resolve({ error: 'Must join mesh first' });
-    return fetch(this.serverUrl + '/api/mesh/channels/' + encodeURIComponent(channel) + '/messages', {
+    if (!this.serverUrl || !this._meshAgentId) return Promise.reject(new Error('Must join mesh first'));
+    return _meshReq(this.serverUrl + '/api/mesh/messages', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(Object.assign({ senderId: this._meshAgentId, messageType: messageType, subject: subject, payload: payload }, opts || {}))
-    }).then(function(r) { return r.json(); });
+      body: JSON.stringify({ channelName: channel || 'general', senderId: this._meshAgentId, targetId: (opts || {}).targetId, type: messageType, subject: subject, payload: payload, priority: (opts || {}).priority, ttl: (opts || {}).ttl })
+    }).then(function(d) { return d.message; });
   };
 
-  WABInstance.prototype.meshReceive = function(channel, limit) {
-    if (!this.serverUrl || !this._meshAgentId) return Promise.resolve({ error: 'Must join mesh first' });
-    return fetch(this.serverUrl + '/api/mesh/agents/' + this._meshAgentId + '/messages/' + encodeURIComponent(channel) + '?limit=' + (limit || 20))
-      .then(function(r) { return r.json(); });
+  WABInstance.prototype.meshReceive = function(limit) {
+    if (!this.serverUrl || !this._meshAgentId) return Promise.reject(new Error('Must join mesh first'));
+    return _meshReq(this.serverUrl + '/api/mesh/messages?agentId=' + this._meshAgentId + '&limit=' + (limit || 50))
+      .then(function(d) { return d.messages; });
+  };
+
+  WABInstance.prototype.meshAcknowledge = function(messageId) {
+    if (!this.serverUrl) return Promise.reject(new Error('Requires server URL'));
+    return _meshReq(this.serverUrl + '/api/mesh/messages/' + encodeURIComponent(messageId) + '/acknowledge', { method: 'POST' });
+  };
+
+  WABInstance.prototype.meshUnread = function() {
+    if (!this.serverUrl || !this._meshAgentId) return Promise.reject(new Error('Must join mesh first'));
+    return _meshReq(this.serverUrl + '/api/mesh/agents/' + this._meshAgentId + '/unread');
   };
 
-  WABInstance.prototype.meshShareKnowledge = function(knowledgeType, domain, key, value, confidence) {
-    if (!this.serverUrl || !this._meshAgentId) return Promise.resolve({ error: 'Must join mesh first' });
-    return fetch(this.serverUrl + '/api/mesh/knowledge', {
+  WABInstance.prototype.meshShareKnowledge = function(type, key, value, opts) {
+    if (!this.serverUrl || !this._meshAgentId) return Promise.reject(new Error('Must join mesh first'));
+    opts = opts || {};
+    return _meshReq(this.serverUrl + '/api/mesh/knowledge', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ agentId: this._meshAgentId, knowledgeType: knowledgeType, domain: domain, key: key, value: value, confidence: confidence })
-    }).then(function(r) { return r.json(); });
+      body: JSON.stringify({ agentId: this._meshAgentId, type: type, domain: opts.domain, key: key, value: value, confidence: opts.confidence, source: opts.source })
+    }).then(function(d) { return d.knowledge; });
+  };
+
+  WABInstance.prototype.meshQueryKnowledge = function(params) {
+    if (!this.serverUrl) return Promise.reject(new Error('Requires server URL'));
+    var qs = Object.keys(params || {}).map(function(k) { return k + '=' + encodeURIComponent(params[k]); }).join('&');
+    return _meshReq(this.serverUrl + '/api/mesh/knowledge?' + qs).then(function(d) { return d.knowledge; });
+  };
+
+  WABInstance.prototype.meshSearchKnowledge = function(query, limit) {
+    if (!this.serverUrl) return Promise.reject(new Error('Requires server URL'));
+    return _meshReq(this.serverUrl + '/api/mesh/knowledge/search/' + encodeURIComponent(query) + '?limit=' + (limit || 20))
+      .then(function(d) { return d.knowledge; });
   };
 
   WABInstance.prototype.meshAlert = function(subject, details, priority) {
-    if (!this.serverUrl || !this._meshAgentId) return Promise.resolve({ error: 'Must join mesh first' });
-    return fetch(this.serverUrl + '/api/mesh/alerts', {
+    if (!this.serverUrl || !this._meshAgentId) return Promise.reject(new Error('Must join mesh first'));
+    return _meshReq(this.serverUrl + '/api/mesh/alert', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ senderId: this._meshAgentId, subject: subject, details: details, priority: priority })
-    }).then(function(r) { return r.json(); });
+    }).then(function(d) { return d.message; });
+  };
+
+  WABInstance.prototype.meshCreateVote = function(subject, options, deadlineSeconds) {
+    if (!this.serverUrl || !this._meshAgentId) return Promise.reject(new Error('Must join mesh first'));
+    return _meshReq(this.serverUrl + '/api/mesh/votes', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ senderId: this._meshAgentId, subject: subject, options: options, deadlineSeconds: deadlineSeconds })
+    }).then(function(d) { return d.vote; });
+  };
+
+  WABInstance.prototype.meshCastVote = function(voteMessageId, choice, weight, reason) {
+    if (!this.serverUrl || !this._meshAgentId) return Promise.reject(new Error('Must join mesh first'));
+    return _meshReq(this.serverUrl + '/api/mesh/votes/' + encodeURIComponent(voteMessageId) + '/cast', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ voterId: this._meshAgentId, choice: choice, weight: weight, reason: reason })
+    }).then(function(d) { return d.result; });
+  };
+
+  WABInstance.prototype.meshTallyVote = function(voteMessageId) {
+    if (!this.serverUrl) return Promise.reject(new Error('Requires server URL'));
+    return _meshReq(this.serverUrl + '/api/mesh/votes/' + encodeURIComponent(voteMessageId) + '/tally')
+      .then(function(d) { return d.tally; });
   };
 
   // ── Agent Symphony Orchestrator ───────────────────────────────────
 
-  WABInstance.prototype.symphonyPerform = function(task, taskType, inputData) {
-    if (!this.serverUrl) return Promise.resolve({ error: 'Symphony requires a server URL' });
+  WABInstance.prototype.symphonyPerform = function(template, inputData, schema) {
+    if (!this.serverUrl) return Promise.reject(new Error('Symphony requires a server URL'));
     var self = this;
-    return fetch(this.serverUrl + '/api/mesh/symphony/perform', {
+    return _meshReq(this.serverUrl + '/api/mesh/symphony/compose', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ siteId: this.name, task: task, taskType: taskType, inputData: inputData })
-    }).then(function(r) { return r.json(); }).then(function(data) {
+      body: JSON.stringify({ siteId: this.name, template: template, inputData: inputData, schema: schema })
+    }).then(function(data) {
       self._emit('symphony:completed', data);
       return data;
     });
@@ -423,30 +488,30 @@
   // ── Agent Learning Engine ─────────────────────────────────────────
 
   WABInstance.prototype.learnRecord = function(domain, action, context, features) {
-    if (!this.serverUrl || !this._meshAgentId) return Promise.resolve({ error: 'Must join mesh first' });
-    return fetch(this.serverUrl + '/api/mesh/learning/decisions', {
+    if (!this.serverUrl || !this._meshAgentId) return Promise.reject(new Error('Must join mesh first'));
+    return _meshReq(this.serverUrl + '/api/mesh/learning/decisions', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ siteId: this.name, agentId: this._meshAgentId, domain: domain, action: action, context: context, features: features })
-    }).then(function(r) { return r.json(); });
+    });
   };
 
   WABInstance.prototype.learnFeedback = function(decisionId, outcome, reward) {
-    if (!this.serverUrl) return Promise.resolve({ error: 'Learning requires a server URL' });
-    return fetch(this.serverUrl + '/api/mesh/learning/decisions/' + decisionId + '/feedback', {
+    if (!this.serverUrl) return Promise.reject(new Error('Learning requires a server URL'));
+    return _meshReq(this.serverUrl + '/api/mesh/learning/feedback', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ outcome: outcome, reward: reward })
-    }).then(function(r) { return r.json(); });
+      body: JSON.stringify({ decisionId: decisionId, outcome: outcome, reward: reward })
+    });
   };
 
   WABInstance.prototype.learnRecommend = function(domain, actions, context) {
-    if (!this.serverUrl || !this._meshAgentId) return Promise.resolve({ error: 'Must join mesh first' });
-    return fetch(this.serverUrl + '/api/mesh/learning/recommend', {
+    if (!this.serverUrl || !this._meshAgentId) return Promise.reject(new Error('Must join mesh first'));
+    return _meshReq(this.serverUrl + '/api/mesh/learning/recommend', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ siteId: this.name, agentId: this._meshAgentId, domain: domain, actions: actions, context: context })
-    }).then(function(r) { return r.json(); });
+    });
   };
 
   // ── Static API ────────────────────────────────────────────────────
@@ -460,80 +525,52 @@
       return instance;
     },
 
-    // Connect to a remote WAB server (for client pages that don't define actions)
     connect: function(serverUrl) {
       return new WABInstance({ name: 'WAB Client', serverUrl: serverUrl });
     },
 
     discover: function() {
       if (WAB._instance) return WAB._instance.discover();
-      return Promise.resolve({ error: 'WAB not initialized. Call WAB.init() first.' });
+      return Promise.reject(new Error('WAB not initialized. Call WAB.init() first.'));
     },
 
     execute: function(actionName, params) {
       if (WAB._instance) return WAB._instance.execute(actionName, params);
-      return Promise.resolve({ error: 'WAB not initialized. Call WAB.init() first.' });
+      return Promise.reject(new Error('WAB not initialized. Call WAB.init() first.'));
     },
 
     negotiate: function(agentId, proposal) {
       if (WAB._instance) return WAB._instance.negotiate(agentId, proposal);
-      return Promise.resolve({ error: 'WAB not initialized' });
+      return Promise.reject(new Error('WAB not initialized'));
     },
 
     getReputation: function(siteId) {
       if (WAB._instance) return WAB._instance.getReputation(siteId);
-      return Promise.resolve({ error: 'WAB not initialized' });
+      return Promise.reject(new Error('WAB not initialized'));
     },
 
     verifyPrice: function(opts) {
       if (WAB._instance) return WAB._instance.verifyPrice(opts);
-      return Promise.resolve({ error: 'WAB not initialized' });
-    },
-
-    meshJoin: function(role, displayName, capabilities) {
-      if (WAB._instance) return WAB._instance.meshJoin(role, displayName, capabilities);
-      return Promise.resolve({ error: 'WAB not initialized' });
-    },
-
-    meshPublish: function(channel, messageType, subject, payload, opts) {
-      if (WAB._instance) return WAB._instance.meshPublish(channel, messageType, subject, payload, opts);
-      return Promise.resolve({ error: 'WAB not initialized' });
+      return Promise.reject(new Error('WAB not initialized'));
     },
 
-    meshReceive: function(channel, limit) {
-      if (WAB._instance) return WAB._instance.meshReceive(channel, limit);
-      return Promise.resolve({ error: 'WAB not initialized' });
-    },
-
-    meshShareKnowledge: function(knowledgeType, domain, key, value, confidence) {
-      if (WAB._instance) return WAB._instance.meshShareKnowledge(knowledgeType, domain, key, value, confidence);
-      return Promise.resolve({ error: 'WAB not initialized' });
-    },
-
-    meshAlert: function(subject, details, priority) {
-      if (WAB._instance) return WAB._instance.meshAlert(subject, details, priority);
-      return Promise.resolve({ error: 'WAB not initialized' });
-    },
-
-    symphonyPerform: function(task, taskType, inputData) {
-      if (WAB._instance) return WAB._instance.symphonyPerform(task, taskType, inputData);
-      return Promise.resolve({ error: 'WAB not initialized' });
-    },
-
-    learnRecord: function(domain, action, context, features) {
-      if (WAB._instance) return WAB._instance.learnRecord(domain, action, context, features);
-      return Promise.resolve({ error: 'WAB not initialized' });
-    },
-
-    learnFeedback: function(decisionId, outcome, reward) {
-      if (WAB._instance) return WAB._instance.learnFeedback(decisionId, outcome, reward);
-      return Promise.resolve({ error: 'WAB not initialized' });
-    },
-
-    learnRecommend: function(domain, actions, context) {
-      if (WAB._instance) return WAB._instance.learnRecommend(domain, actions, context);
-      return Promise.resolve({ error: 'WAB not initialized' });
-    },
+    meshJoin: function(r, d, c) { return WAB._instance ? WAB._instance.meshJoin(r, d, c) : Promise.reject(new Error('WAB not initialized')); },
+    meshLeave: function() { return WAB._instance ? WAB._instance.meshLeave() : Promise.reject(new Error('WAB not initialized')); },
+    meshPublish: function(ch, mt, s, p, o) { return WAB._instance ? WAB._instance.meshPublish(ch, mt, s, p, o) : Promise.reject(new Error('WAB not initialized')); },
+    meshReceive: function(l) { return WAB._instance ? WAB._instance.meshReceive(l) : Promise.reject(new Error('WAB not initialized')); },
+    meshAcknowledge: function(id) { return WAB._instance ? WAB._instance.meshAcknowledge(id) : Promise.reject(new Error('WAB not initialized')); },
+    meshUnread: function() { return WAB._instance ? WAB._instance.meshUnread() : Promise.reject(new Error('WAB not initialized')); },
+    meshShareKnowledge: function(t, k, v, o) { return WAB._instance ? WAB._instance.meshShareKnowledge(t, k, v, o) : Promise.reject(new Error('WAB not initialized')); },
+    meshQueryKnowledge: function(p) { return WAB._instance ? WAB._instance.meshQueryKnowledge(p) : Promise.reject(new Error('WAB not initialized')); },
+    meshSearchKnowledge: function(q, l) { return WAB._instance ? WAB._instance.meshSearchKnowledge(q, l) : Promise.reject(new Error('WAB not initialized')); },
+    meshAlert: function(s, d, p) { return WAB._instance ? WAB._instance.meshAlert(s, d, p) : Promise.reject(new Error('WAB not initialized')); },
+    meshCreateVote: function(s, o, d) { return WAB._instance ? WAB._instance.meshCreateVote(s, o, d) : Promise.reject(new Error('WAB not initialized')); },
+    meshCastVote: function(id, c, w, r) { return WAB._instance ? WAB._instance.meshCastVote(id, c, w, r) : Promise.reject(new Error('WAB not initialized')); },
+    meshTallyVote: function(id) { return WAB._instance ? WAB._instance.meshTallyVote(id) : Promise.reject(new Error('WAB not initialized')); },
+    symphonyPerform: function(t, i, s) { return WAB._instance ? WAB._instance.symphonyPerform(t, i, s) : Promise.reject(new Error('WAB not initialized')); },
+    learnRecord: function(d, a, c, f) { return WAB._instance ? WAB._instance.learnRecord(d, a, c, f) : Promise.reject(new Error('WAB not initialized')); },
+    learnFeedback: function(id, o, r) { return WAB._instance ? WAB._instance.learnFeedback(id, o, r) : Promise.reject(new Error('WAB not initialized')); },
+    learnRecommend: function(d, a, c) { return WAB._instance ? WAB._instance.learnRecommend(d, a, c) : Promise.reject(new Error('WAB not initialized')); },
 
     _instance: null
   };

package/script/ai-agent-bridge.js

@@ -1428,132 +1428,202 @@
 
     // ── Agent Mesh Protocol (Client-Side) ───────────────────────────────
 
-    /**
-     * Join the agent mesh — register this agent and return its mesh identity.
-     */
-    async meshJoin(role, displayName, capabilities) {
+    async _meshPost(path, body) {
       const base = this._resolveApiBase();
-      const res = await fetch(`${base}/api/mesh/agents`, {
+      const res = await fetch(`${base}/api/mesh${path}`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ siteId: this.config.siteId, role, displayName, capabilities })
+        body: body ? JSON.stringify(body) : undefined
       });
-      const data = await res.json();
-      this._meshAgentId = data.id;
-      this.events.emit('mesh:joined', data);
-      return data;
+      if (!res.ok) { const e = await res.json().catch(() => ({})); throw new Error(e.error || res.statusText); }
+      return res.json();
     }
 
-    /**
-     * Publish a message to a mesh channel.
-     */
-    async meshPublish(channel, messageType, subject, payload, opts) {
-      if (!this._meshAgentId) throw new Error('Must call meshJoin() first');
+    async _meshGet(path) {
       const base = this._resolveApiBase();
-      const res = await fetch(`${base}/api/mesh/channels/${encodeURIComponent(channel)}/messages`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ senderId: this._meshAgentId, messageType, subject, payload, ...opts })
-      });
+      const res = await fetch(`${base}/api/mesh${path}`);
+      if (!res.ok) { const e = await res.json().catch(() => ({})); throw new Error(e.error || res.statusText); }
       return res.json();
     }
 
-    /**
-     * Get unread mesh messages for this agent on a channel.
-     */
-    async meshReceive(channel, limit) {
-      if (!this._meshAgentId) throw new Error('Must call meshJoin() first');
+    async _meshDelete(path) {
       const base = this._resolveApiBase();
-      const res = await fetch(`${base}/api/mesh/agents/${this._meshAgentId}/messages/${encodeURIComponent(channel)}?limit=${limit || 20}`);
+      const res = await fetch(`${base}/api/mesh${path}`, { method: 'DELETE' });
+      if (!res.ok) { const e = await res.json().catch(() => ({})); throw new Error(e.error || res.statusText); }
       return res.json();
     }
 
-    /**
-     * Share knowledge to the mesh.
-     */
-    async meshShareKnowledge(knowledgeType, domain, key, value, confidence) {
+    async meshJoin(role, displayName, capabilities) {
+      const data = await this._meshPost('/agents', { siteId: this.config.siteId, role, displayName, capabilities });
+      this._meshAgentId = data.agent.id;
+      this._meshHeartbeat = setInterval(() => {
+        this._meshPost(`/agents/${this._meshAgentId}/heartbeat`).catch(() => {});
+      }, 30000);
+      this.events.emit('mesh:joined', data.agent);
+      return data.agent;
+    }
+
+    async meshLeave() {
+      if (this._meshHeartbeat) { clearInterval(this._meshHeartbeat); this._meshHeartbeat = null; }
+      if (this._meshAgentId) {
+        await this._meshDelete(`/agents/${this._meshAgentId}`).catch(() => {});
+        this._meshAgentId = null;
+      }
+    }
+
+    async meshPublish(channel, messageType, subject, payload, opts) {
       if (!this._meshAgentId) throw new Error('Must call meshJoin() first');
-      const base = this._resolveApiBase();
-      const res = await fetch(`${base}/api/mesh/knowledge`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ agentId: this._meshAgentId, knowledgeType, domain, key, value, confidence })
-      });
-      return res.json();
+      return (await this._meshPost('/messages', {
+        channelName: channel || 'general', senderId: this._meshAgentId,
+        targetId: opts?.targetId, type: messageType, subject, payload,
+        priority: opts?.priority, ttl: opts?.ttl
+      })).message;
+    }
+
+    async meshReceive(limit) {
+      if (!this._meshAgentId) throw new Error('Must call meshJoin() first');
+      return (await this._meshGet(`/messages?agentId=${this._meshAgentId}&limit=${limit || 50}`)).messages;
+    }
+
+    async meshAcknowledge(messageId) {
+      return this._meshPost(`/messages/${encodeURIComponent(messageId)}/acknowledge`);
+    }
+
+    async meshUnread() {
+      if (!this._meshAgentId) throw new Error('Must call meshJoin() first');
+      return this._meshGet(`/agents/${this._meshAgentId}/unread`);
+    }
+
+    async meshShareKnowledge(type, key, value, opts) {
+      if (!this._meshAgentId) throw new Error('Must call meshJoin() first');
+      return (await this._meshPost('/knowledge', {
+        agentId: this._meshAgentId, type, domain: opts?.domain,
+        key, value, confidence: opts?.confidence, source: opts?.source
+      })).knowledge;
+    }
+
+    async meshQueryKnowledge(params) {
+      const qs = new URLSearchParams(params || {}).toString();
+      return (await this._meshGet(`/knowledge?${qs}`)).knowledge;
+    }
+
+    async meshSearchKnowledge(query, limit) {
+      return (await this._meshGet(`/knowledge/search/${encodeURIComponent(query)}?limit=${limit || 20}`)).knowledge;
     }
 
-    /**
-     * Broadcast an alert to all mesh agents.
-     */
     async meshAlert(subject, details, priority) {
       if (!this._meshAgentId) throw new Error('Must call meshJoin() first');
-      const base = this._resolveApiBase();
-      const res = await fetch(`${base}/api/mesh/alerts`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ senderId: this._meshAgentId, subject, details, priority })
-      });
-      return res.json();
+      return (await this._meshPost('/alert', { senderId: this._meshAgentId, subject, details, priority })).message;
     }
 
-    /**
-     * Run a full symphony — orchestrate specialized agents for a task.
-     */
-    async symphonyPerform(task, taskType, inputData) {
-      const base = this._resolveApiBase();
-      const res = await fetch(`${base}/api/mesh/symphony/perform`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ siteId: this.config.siteId, task, taskType, inputData })
+    async meshCreateVote(subject, options, deadlineSeconds) {
+      if (!this._meshAgentId) throw new Error('Must call meshJoin() first');
+      return (await this._meshPost('/votes', { senderId: this._meshAgentId, subject, options, deadlineSeconds })).vote;
+    }
+
+    async meshCastVote(voteMessageId, choice, weight, reason) {
+      if (!this._meshAgentId) throw new Error('Must call meshJoin() first');
+      return (await this._meshPost(`/votes/${encodeURIComponent(voteMessageId)}/cast`, {
+        voterId: this._meshAgentId, choice, weight, reason
+      })).result;
+    }
+
+    async meshTallyVote(voteMessageId) {
+      return (await this._meshGet(`/votes/${encodeURIComponent(voteMessageId)}/tally`)).tally;
+    }
+
+    async symphonyPerform(template, inputData, schema) {
+      const data = await this._meshPost('/symphony/compose', {
+        siteId: this.config.siteId, template, inputData, schema
       });
-      const data = await res.json();
       this.events.emit('symphony:completed', data);
       return data;
     }
 
-    /**
-     * Record a decision for the learning engine and get prediction.
-     */
     async learnRecord(domain, action, context, features) {
       if (!this._meshAgentId) throw new Error('Must call meshJoin() first');
-      const base = this._resolveApiBase();
-      const res = await fetch(`${base}/api/mesh/learning/decisions`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ siteId: this.config.siteId, agentId: this._meshAgentId, domain, action, context, features })
+      return this._meshPost('/learning/decisions', {
+        siteId: this.config.siteId, agentId: this._meshAgentId, domain, action, context, features
       });
-      return res.json();
     }
 
-    /**
-     * Provide feedback on a decision — the learning signal.
-     */
     async learnFeedback(decisionId, outcome, reward) {
-      const base = this._resolveApiBase();
-      const res = await fetch(`${base}/api/mesh/learning/decisions/${decisionId}/feedback`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ outcome, reward })
-      });
-      return res.json();
+      return this._meshPost('/learning/feedback', { decisionId, outcome, reward });
     }
 
-    /**
-     * Get recommendation from learning engine.
-     */
     async learnRecommend(domain, actions, context) {
       if (!this._meshAgentId) throw new Error('Must call meshJoin() first');
-      const base = this._resolveApiBase();
-      const res = await fetch(`${base}/api/mesh/learning/recommend`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ siteId: this.config.siteId, agentId: this._meshAgentId, domain, actions, context })
+      return this._meshPost('/learning/recommend', {
+        siteId: this.config.siteId, agentId: this._meshAgentId, domain, actions, context
+      });
+    }
+
+    // ── Commander Agent Protocol ────────────────────────────────────────
+
+    async _cmdPost(path, body) {
+      const base = this.config.serverUrl || '';
+      const res = await fetch(`${base}/api/commander${path}`, {
+        method: 'POST', headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body)
       });
+      if (!res.ok) throw new Error(`Commander POST ${path} failed: ${res.status}`);
       return res.json();
     }
 
+    async _cmdGet(path) {
+      const base = this.config.serverUrl || '';
+      const res = await fetch(`${base}/api/commander${path}`);
+      if (!res.ok) throw new Error(`Commander GET ${path} failed: ${res.status}`);
+      return res.json();
+    }
+
+    /** Launch a mission — decompose a goal and execute it. */
+    async commanderLaunch(goal, options) {
+      const data = await this._cmdPost('/missions/launch', {
+        siteId: this.config.siteId, goal,
+        title: options?.title || goal.substring(0, 80),
+        strategy: options?.strategy,
+        priority: options?.priority, context: options?.context
+      });
+      this.events.emit('commander:mission', data.mission);
+      return data.mission;
+    }
+
+    /** Get commander + edge + local AI stats. */
+    async commanderStats() {
+      return this._cmdGet(`/stats?siteId=${encodeURIComponent(this.config.siteId || 'default')}`);
+    }
+
+    /** Register an edge computing node. */
+    async edgeRegisterNode(hostname, hardware, capabilities) {
+      return this._cmdPost('/edge/nodes', {
+        siteId: this.config.siteId, hostname, hardware, capabilities
+      });
+    }
+
+    /** Submit a task to the edge computing queue. */
+    async edgeSubmitTask(taskType, payload, options) {
+      return this._cmdPost('/edge/tasks', { taskType, payload, ...options });
+    }
+
+    /** Discover local AI models (Ollama, llama.cpp, etc.). */
+    async localAIDiscover(customEndpoints) {
+      return this._cmdPost('/local-ai/discover', {
+        siteId: this.config.siteId, customEndpoints
+      });
+    }
+
+    /** Run inference on a local AI model. */
+    async localAIInfer(prompt, options) {
+      return this._cmdPost('/local-ai/infer', {
+        siteId: this.config.siteId, prompt, ...options
+      });
+    }
+
     destroy() {
       this.events.emit('destroy');
+      if (this._meshHeartbeat) { clearInterval(this._meshHeartbeat); this._meshHeartbeat = null; }
+      this._meshAgentId = null;
       if (this._mutationObserver) {
         this._mutationObserver.disconnect();
         this._mutationObserver = null;