aimeat 2.0.0 → 2.2.0

package/dist/static/sdk-libs/dist/aimeat-capabilities.js

@@ -0,0 +1,177 @@
+// GENERATED FILE — do not edit directly. Source: src/static/sdk-libs/capabilities/ (+ _core/).
+// Rebuild: pnpm build:sdk  ·  Served at /v1/libs/aimeat-capabilities.js (with a per-node config prelude).
+"use strict";
+(() => {
+  // src/static/sdk-libs/_core/session.js
+  function getSession(libLabel) {
+    const auth = window.AIMEAT && window.AIMEAT.auth;
+    if (!auth) {
+      throw new Error("AIMEAT.auth is required. Include aimeat-auth.js before " + (libLabel || "this library"));
+    }
+    const s = auth.getSession();
+    if (!s) throw new Error("Not logged in. Call AIMEAT.auth.login() first.");
+    return s;
+  }
+  function authFetch(path, opts, libLabel) {
+    return getSession(libLabel).fetch(path, opts);
+  }
+  function makeSession(libLabel) {
+    return {
+      getSession: () => getSession(libLabel),
+      authFetch: (path, opts) => authFetch(path, opts, libLabel)
+    };
+  }
+
+  // src/static/sdk-libs/_core/namespace.js
+  function namespace() {
+    if (!window.AIMEAT) window.AIMEAT = {};
+    return window.AIMEAT;
+  }
+  function attach(key, value) {
+    const ns = namespace();
+    ns[key] = value;
+    return ns;
+  }
+
+  // src/static/sdk-libs/capabilities/index.js
+  var { getSession: getSession2, authFetch: authFetch2 } = makeSession("aimeat-capabilities.js");
+  var _loadedCortex = {};
+  async function loadCortexLib(url) {
+    if (_loadedCortex[url]) return;
+    return new Promise(function(resolve, reject) {
+      var s = document.createElement("script");
+      s.src = url;
+      s.onload = function() {
+        _loadedCortex[url] = true;
+        resolve(void 0);
+      };
+      s.onerror = function() {
+        reject(new Error("Failed to load: " + url));
+      };
+      document.head.appendChild(s);
+    });
+  }
+  var capabilities = {
+    // ── Discovery ──
+    async list(filters) {
+      var params = new URLSearchParams();
+      if (filters) {
+        if (filters.search) params.set("search", filters.search);
+        if (filters.tags) params.set("tags", filters.tags.join(","));
+        if (filters.callable !== void 0) params.set("callable", String(filters.callable));
+        if (filters.authRequired) params.set("authRequired", filters.authRequired);
+        if (filters.source_type) params.set("source_type", filters.source_type);
+        if (filters.status) params.set("status", filters.status);
+        if (filters.page) params.set("page", String(filters.page));
+        if (filters.per_page) params.set("per_page", String(filters.per_page));
+      }
+      var qs = params.toString();
+      var res = await authFetch2("/v1/capabilities" + (qs ? "?" + qs : ""));
+      if (!res.ok) throw new Error(res.error?.message || "Failed to list capabilities");
+      return res.data;
+    },
+    async search(query) {
+      return capabilities.list({ search: query });
+    },
+    async get(id) {
+      var res = await authFetch2("/v1/capabilities/" + encodeURIComponent(id));
+      if (!res.ok) throw new Error(res.error?.message || "Capability not found");
+      return res.data;
+    },
+    // ── Invocation ──
+    async invoke(id, input, opts) {
+      var cap = await capabilities.get(id);
+      var mode = opts && opts.mode || "normal";
+      if (cap.source && cap.source.type === "cortex") {
+        var usage = cap.usage || "";
+        var libMatch = usage.match(/loadScript\(['"]([^'"]+)['"]/);
+        if (libMatch) {
+          await loadCortexLib(libMatch[1]);
+        }
+        if (cap.exports && cap.exports.length > 0) {
+          var parts = id.split(":");
+          var funcName = parts.length >= 3 ? parts[2] : null;
+          if (funcName) {
+            var fn = window[funcName] || window.AIMEAT && window.AIMEAT[funcName];
+            if (typeof fn === "function") {
+              var start = performance.now();
+              var result = await fn(input);
+              var duration = Math.round(performance.now() - start);
+              try {
+                authFetch2("/v1/capabilities/" + encodeURIComponent(id) + "/telemetry", {
+                  method: "POST",
+                  body: JSON.stringify({ duration_ms: duration, status: "success" })
+                }).catch(function() {
+                });
+              } catch {
+              }
+              return result;
+            }
+          }
+        }
+        throw new Error("Cortex capability loaded but export function not found. Use direct loadScript() instead.");
+      }
+      var res = await authFetch2("/v1/capabilities/" + encodeURIComponent(id) + "/invoke" + (mode === "raw" ? "?mode=raw" : ""), {
+        method: "POST",
+        body: JSON.stringify({ input: input || {} })
+      });
+      if (!res.ok) throw new Error(res.error?.message || "Invoke failed");
+      return res.data.result !== void 0 ? res.data.result : res.data;
+    },
+    // ── Management ──
+    async create(record) {
+      var res = await authFetch2("/v1/capabilities", {
+        method: "POST",
+        body: JSON.stringify(record)
+      });
+      if (!res.ok) throw new Error(res.error?.message || "Failed to create capability");
+      return res.data;
+    },
+    async update(id, updates) {
+      var res = await authFetch2("/v1/capabilities/" + encodeURIComponent(id), {
+        method: "PUT",
+        body: JSON.stringify(updates)
+      });
+      if (!res.ok) throw new Error(res.error?.message || "Failed to update capability");
+      return res.data;
+    },
+    async delete(id) {
+      var res = await authFetch2("/v1/capabilities/" + encodeURIComponent(id), {
+        method: "DELETE"
+      });
+      if (!res.ok) throw new Error(res.error?.message || "Failed to delete capability");
+      return res.data;
+    },
+    async mine() {
+      var session = getSession2();
+      return capabilities.list({ owner: session.ghii || session.owner });
+    },
+    // ── Testing ──
+    async test(id, input) {
+      var res = await authFetch2("/v1/capabilities/" + encodeURIComponent(id) + "/test", {
+        method: "POST",
+        body: JSON.stringify({ input: input || {} })
+      });
+      if (!res.ok) throw new Error(res.error?.message || "Test failed");
+      return res.data;
+    },
+    // ── Vouching ──
+    async vouch(id, comment) {
+      var body = comment ? { comment } : {};
+      var res = await authFetch2("/v1/capabilities/" + encodeURIComponent(id) + "/vouch", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) throw new Error(res.error?.message || "Vouch failed");
+      return res.data;
+    },
+    async unvouch(id) {
+      var res = await authFetch2("/v1/capabilities/" + encodeURIComponent(id) + "/vouch", {
+        method: "DELETE"
+      });
+      if (!res.ok) throw new Error(res.error?.message || "Unvouch failed");
+      return res.data;
+    }
+  };
+  attach("capabilities", capabilities);
+})();

package/dist/static/sdk-libs/dist/aimeat-commerce.js

@@ -0,0 +1,265 @@
+// GENERATED FILE — do not edit directly. Source: src/static/sdk-libs/commerce/ (+ _core/).
+// Rebuild: pnpm build:sdk  ·  Served at /v1/libs/aimeat-commerce.js (with a per-node config prelude).
+"use strict";
+(() => {
+  // src/static/sdk-libs/_core/config.js
+  function cfg() {
+    return window.__AIMEAT_SDK_CFG__ || { nodeId: "", baseUrl: "" };
+  }
+  function resolveNodeUrl() {
+    const meta = document.querySelector('meta[name="aimeat-node"]');
+    if (meta) return (meta.getAttribute("content") || "").replace(/\/$/, "");
+    if (location.protocol === "http:" || location.protocol === "https:") return location.origin;
+    return cfg().baseUrl;
+  }
+  var NODE_URL = resolveNodeUrl();
+  var APEX_URL = cfg().baseUrl;
+  var NODE_ID = cfg().nodeId;
+  var HEARTBEAT_MS = cfg().heartbeatMs || 3e4;
+
+  // src/static/sdk-libs/_core/session.js
+  function getSession(libLabel) {
+    const auth = window.AIMEAT && window.AIMEAT.auth;
+    if (!auth) {
+      throw new Error("AIMEAT.auth is required. Include aimeat-auth.js before " + (libLabel || "this library"));
+    }
+    const s = auth.getSession();
+    if (!s) throw new Error("Not logged in. Call AIMEAT.auth.login() first.");
+    return s;
+  }
+  function authFetch(path, opts, libLabel) {
+    return getSession(libLabel).fetch(path, opts);
+  }
+  function makeSession(libLabel) {
+    return {
+      getSession: () => getSession(libLabel),
+      authFetch: (path, opts) => authFetch(path, opts, libLabel)
+    };
+  }
+
+  // src/static/sdk-libs/_core/namespace.js
+  function namespace() {
+    if (!window.AIMEAT) window.AIMEAT = {};
+    return window.AIMEAT;
+  }
+  function attach(key, value) {
+    const ns = namespace();
+    ns[key] = value;
+    return ns;
+  }
+
+  // src/static/sdk-libs/commerce/index.js
+  var { authFetch: authFetch2 } = makeSession("aimeat-commerce.js");
+  var NODE_URL2 = APEX_URL;
+  var MONEY_UNIT = 1e6;
+  function commerceError(res, fallback) {
+    const e = (
+      /** @type {Error & { code?: string, paymentRequired?: boolean, accepts?: unknown, x402Version?: unknown }} */
+      new Error(res.error && res.error.message || fallback)
+    );
+    e.code = res.error && res.error.code;
+    if (res.accepts) {
+      e.paymentRequired = true;
+      e.accepts = res.accepts;
+      e.x402Version = res.x402Version;
+    }
+    return e;
+  }
+  function normalizeItems(items) {
+    const arr = Array.isArray(items) ? items : [items];
+    return arr.map(function(i) {
+      const out = (
+        /** @type {Record<string, any>} */
+        { offer_id: i.offer_id || i.offerId }
+      );
+      if (i.kind) out.kind = i.kind;
+      if (i.agent) out.agent = i.agent;
+      if (i.org) out.org = i.org;
+      if (i.app) out.app = i.app;
+      if (i.tool) out.tool = i.tool;
+      if (i.input) out.input = i.input;
+      if (i.quantity) out.quantity = i.quantity;
+      return out;
+    });
+  }
+  var commerce = {
+    MONEY_UNIT,
+    // ── Money formatting (same convention as the portal's utils.js fmtMoney) ──
+    /** Format money micro-units as "1.50 EUR" / "0.002 USD" (≥2 decimals, up to 6 when sub-cent). */
+    fmtMoney(micros, currency) {
+      const s = ((Number(micros) || 0) / MONEY_UNIT).toFixed(6).replace(/(\.\d{2}\d*?)0+$/, "$1");
+      return currency ? s + " " + currency : s;
+    },
+    /** Format any session/offer amount currency-aware: morsels are integers, money is micro-units. */
+    fmtAmount(amount, currency) {
+      if (!currency || currency === "morsel" || currency === "MORSEL") {
+        return (Number(amount) || 0) + " morsels";
+      }
+      return commerce.fmtMoney(amount, currency);
+    },
+    /** Parse a major-unit input ("1.50", "0,002") into integer money micro-units; null if not positive. */
+    microsFromInput(str) {
+      const n = parseFloat(String(str).replace(",", "."));
+      if (!Number.isFinite(n) || n <= 0) return null;
+      return Math.round(n * MONEY_UNIT);
+    },
+    // ── Offer discovery + price reading ──
+    /** Public product feed: every PUBLIC, priced agent offer on the node (no login needed). */
+    async feed() {
+      const r = await fetch(NODE_URL2 + "/v1/commerce/feed");
+      const res = await r.json();
+      if (res.error) throw commerceError(res, "Failed to read the commerce feed");
+      return res;
+    },
+    /** Read one offer (with price/priceMoney) from an agent's published offers. */
+    async getOffer(agent, offerId) {
+      const res = await authFetch2("/v1/agents/" + encodeURIComponent(agent) + "/offers");
+      if (!res.ok) throw commerceError(res, "Failed to read offers");
+      const offers = res.data && res.data.offers || [];
+      return offers.find(function(o) {
+        return o.id === offerId;
+      }) || null;
+    },
+    /**
+     * The price of an offer or app-tool entry in one currency.
+     * → { amount, currency, formatted } or null when it has no price in that currency.
+     * currency omitted/'morsel' → price.morsels; 'EUR'/'USD' → priceMoney micro-units.
+     */
+    priceOf(offer, currency) {
+      if (!offer) return null;
+      if (!currency || currency === "morsel") {
+        const m = offer.price && Number(offer.price.morsels);
+        if (!m || m <= 0) return null;
+        return { amount: m, currency: "morsel", formatted: commerce.fmtAmount(m, "morsel") };
+      }
+      const pm = offer.priceMoney;
+      if (!pm || pm.currency !== currency) return null;
+      return { amount: pm.amount, currency, formatted: commerce.fmtMoney(pm.amount, currency) };
+    },
+    // ── Checkout sessions (/v1/commerce/checkout-sessions) ──
+    /**
+     * Open a checkout session. items: [{ agent, offer_id, quantity? }] (kind defaults to 'offer').
+     * opts: { note?, currency? } — currency 'EUR'/'USD' needs a money price + a settling handler.
+     */
+    async openCheckout(items, opts) {
+      const body = (
+        /** @type {Record<string, any>} */
+        { items: normalizeItems(items) }
+      );
+      if (opts && opts.note) body.note = opts.note;
+      if (opts && opts.currency) body.currency = opts.currency;
+      const res = await authFetch2("/v1/commerce/checkout-sessions", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) throw commerceError(res, "Failed to open checkout");
+      return res.data.session;
+    },
+    /** Read one of the buyer's checkout sessions. */
+    async getCheckout(id) {
+      const res = await authFetch2("/v1/commerce/checkout-sessions/" + encodeURIComponent(id));
+      if (!res.ok) throw commerceError(res, "Failed to read checkout");
+      return res.data.session;
+    },
+    /** The buyer's checkout sessions (purchases), newest first. */
+    async listCheckouts(opts) {
+      const qs = opts && opts.limit ? "?limit=" + opts.limit : "";
+      const res = await authFetch2("/v1/commerce/checkout-sessions" + qs);
+      if (!res.ok) throw commerceError(res, "Failed to list checkouts");
+      return res.data.sessions;
+    },
+    /** Replace the cart of an open session. */
+    async updateCheckout(id, items) {
+      const res = await authFetch2("/v1/commerce/checkout-sessions/" + encodeURIComponent(id), {
+        method: "PATCH",
+        body: JSON.stringify({ items: normalizeItems(items) })
+      });
+      if (!res.ok) throw commerceError(res, "Failed to update checkout");
+      return res.data.session;
+    },
+    /** Cancel an open session. */
+    async cancelCheckout(id) {
+      const res = await authFetch2("/v1/commerce/checkout-sessions/" + encodeURIComponent(id), {
+        method: "PATCH",
+        body: JSON.stringify({ cancel: true })
+      });
+      if (!res.ok) throw commerceError(res, "Failed to cancel checkout");
+      return res.data.session;
+    },
+    /**
+     * Complete (pay + fulfill) a session. payment: { handler?, instrument? } — omit for the
+     * node default (morsels). On 402 the thrown error has err.paymentRequired + err.accepts.
+     * Returns the completed session: session.receipt { handler, charged, fee }, session.fulfillment.
+     */
+    async completeCheckout(id, payment) {
+      const res = await authFetch2("/v1/commerce/checkout-sessions/" + encodeURIComponent(id) + "/complete", {
+        method: "POST",
+        body: JSON.stringify(payment ? { payment } : {})
+      });
+      if (!res.ok) throw commerceError(res, "Failed to complete checkout");
+      return res.data.session;
+    },
+    /** One-call purchase: open a session for one offer and complete it immediately. */
+    async buyOffer(agent, offerId, opts) {
+      const session = await commerce.openCheckout(
+        [{ agent, offer_id: offerId, quantity: opts && opts.quantity || 1 }],
+        opts
+      );
+      return commerce.completeCheckout(session.id, opts && opts.payment);
+    },
+    /** The seller's received orders (completed sessions where you are the seller). */
+    async listOrders(opts) {
+      const qs = opts && opts.limit ? "?limit=" + opts.limit : "";
+      const res = await authFetch2("/v1/commerce/orders" + qs);
+      if (!res.ok) throw commerceError(res, "Failed to list orders");
+      return res.data.orders;
+    },
+    // ── App tools (TARGET-034 — priced tool calls on agent-faced apps) ──
+    /**
+     * Read an app's declared tool manifest: the public memory record apps.{appId}.tools under the
+     * app owner's GHII — { tools: [{ name, description, inputSchema, action_id?, agent?, price?, priceMoney? }] }.
+     * Returns null when the app declares no tools. Works logged out (public read).
+     */
+    async getAppTools(ownerGhii, appId) {
+      const url = NODE_URL2 + "/v1/memory/" + encodeURIComponent(ownerGhii) + "/" + encodeURIComponent("apps." + appId + ".tools");
+      const r = await fetch(url);
+      const res = await r.json();
+      if (!res.ok) {
+        if (res.error && res.error.code === "NOT_FOUND") return null;
+        throw commerceError(res, "Failed to read app tools");
+      }
+      return res.data.value;
+    },
+    /**
+     * Buy + invoke a priced app-tool through the checkout core (TARGET-034):
+     * one { kind:'app-tool', app:'ownerName/appId', tool, input } line item, opened and
+     * completed in one call. A tool bound to a capability (action_id) runs with your input and
+     * the result comes back on session.fulfillment.results[0].result; an unbound tool queues an
+     * agent TASK for the app owner instead — session.fulfillment.taskIds[0] (the deliverable
+     * arrives via the seller's task flow). The receipt shows the charge either way.
+     * One call per invocation. On a node without the resolver this throws
+     * with code 'APP_TOOL_NOT_AVAILABLE'.
+     */
+    async invokeAppTool(ref, opts) {
+      try {
+        const session = await commerce.openCheckout(
+          [{ kind: "app-tool", app: ref.app, tool: ref.tool, input: ref.input }],
+          opts
+        );
+        return commerce.completeCheckout(session.id, opts && opts.payment);
+      } catch (e) {
+        if (e.code === "UNKNOWN_ITEM_KIND" || e.code === "INVALID_CHECKOUT" && /invalid enum|"kind"/i.test(String(e.message))) {
+          const err = (
+            /** @type {Error & { code?: string, cause?: unknown }} */
+            new Error("This node does not sell app-tools (app-tool resolver not enabled)")
+          );
+          err.code = "APP_TOOL_NOT_AVAILABLE";
+          err.cause = e;
+          throw err;
+        }
+        throw e;
+      }
+    }
+  };
+  attach("commerce", commerce);
+})();

package/dist/static/sdk-libs/dist/aimeat-data.js

@@ -0,0 +1,247 @@
+// GENERATED FILE — do not edit directly. Source: src/static/sdk-libs/data/ (+ _core/).
+// Rebuild: pnpm build:sdk  ·  Served at /v1/libs/aimeat-data.js (with a per-node config prelude).
+"use strict";
+(() => {
+  // src/static/sdk-libs/_core/config.js
+  function cfg() {
+    return window.__AIMEAT_SDK_CFG__ || { nodeId: "", baseUrl: "" };
+  }
+  function resolveNodeUrl() {
+    const meta = document.querySelector('meta[name="aimeat-node"]');
+    if (meta) return (meta.getAttribute("content") || "").replace(/\/$/, "");
+    if (location.protocol === "http:" || location.protocol === "https:") return location.origin;
+    return cfg().baseUrl;
+  }
+  var NODE_URL = resolveNodeUrl();
+  var APEX_URL = cfg().baseUrl;
+  var NODE_ID = cfg().nodeId;
+  var HEARTBEAT_MS = cfg().heartbeatMs || 3e4;
+
+  // src/static/sdk-libs/_core/session.js
+  function getSession(libLabel) {
+    const auth = window.AIMEAT && window.AIMEAT.auth;
+    if (!auth) {
+      throw new Error("AIMEAT.auth is required. Include aimeat-auth.js before " + (libLabel || "this library"));
+    }
+    const s = auth.getSession();
+    if (!s) throw new Error("Not logged in. Call AIMEAT.auth.login() first.");
+    return s;
+  }
+  function authFetch(path, opts, libLabel) {
+    return getSession(libLabel).fetch(path, opts);
+  }
+  function makeSession(libLabel) {
+    return {
+      getSession: () => getSession(libLabel),
+      authFetch: (path, opts) => authFetch(path, opts, libLabel)
+    };
+  }
+
+  // src/static/sdk-libs/_core/namespace.js
+  function namespace() {
+    if (!window.AIMEAT) window.AIMEAT = {};
+    return window.AIMEAT;
+  }
+  function attach(key, value) {
+    const ns = namespace();
+    ns[key] = value;
+    return ns;
+  }
+
+  // src/static/sdk-libs/data/index.js
+  var { authFetch: authFetch2 } = makeSession("aimeat-data.js");
+  function scopeParams(opts) {
+    const p = new URLSearchParams();
+    if (opts?.agent) p.set("agent", opts.agent);
+    else if (opts?.ownerScope) p.set("owner_scope", "true");
+    return p;
+  }
+  function withParams(path, params) {
+    const qs = params.toString();
+    if (!qs) return path;
+    return path + (path.indexOf("?") >= 0 ? "&" : "?") + qs;
+  }
+  var data = {
+    // Write or upsert a memory entry
+    async set(key, value, opts) {
+      const body = { key, value, visibility: "private", ...opts };
+      const res = await authFetch2("/v1/memory", { method: "POST", body: JSON.stringify(body) });
+      if (!res.ok) throw new Error(res.error?.message || "Failed to set memory");
+      return res.data;
+    },
+    // Read a single entry (falls back to public read from app creator if not found or empty).
+    // Uses ?soft=1 so a missing key is a clean 200 (value null) — no browser-console 404 noise;
+    // the contract is unchanged: resolves null when the key does not exist.
+    // opts: { agent, ownerScope } — read from one of the owner's agents' namespaces, or
+    // across the owner's whole set (GHII + agents). Omitted → unchanged behaviour.
+    async get(key, opts) {
+      const res = await authFetch2(withParams(
+        "/v1/memory/" + encodeURIComponent(key) + "?soft=1",
+        scopeParams(opts)
+      ));
+      var val = res.ok ? res.data.value : null;
+      var isEmpty = val == null || typeof val === "object" && Object.keys(val).length === 0;
+      if (!isEmpty) return val;
+      if (opts?.agent || opts?.ownerScope) return val;
+      var creator = document.querySelector('meta[name="aimeat-creator"]')?.getAttribute("content");
+      if (!creator) {
+        var m = location.pathname.match(/\/v1\/apps\/([^/]+)\//);
+        if (m) {
+          creator = decodeURIComponent(m[1]);
+          if (creator && !creator.includes("@")) creator = creator + "@" + NODE_ID;
+        }
+      }
+      if (creator) {
+        try {
+          var pub = await data.getPublic(creator, key);
+          if (pub != null) return pub;
+        } catch {
+        }
+      }
+      return val;
+    },
+    // Read full entry metadata. opts: { agent, ownerScope } as in get().
+    async getEntry(key, opts) {
+      const res = await authFetch2(withParams(
+        "/v1/memory/" + encodeURIComponent(key),
+        scopeParams(opts)
+      ));
+      if (!res.ok) {
+        if (res.error?.code === "NOT_FOUND") return null;
+        throw new Error(res.error?.message || "Failed to get memory");
+      }
+      return res.data;
+    },
+    // Update with optimistic locking
+    async update(key, value, version, opts) {
+      const body = { value, version, ...opts };
+      const res = await authFetch2("/v1/memory/" + encodeURIComponent(key), {
+        method: "PUT",
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) throw new Error(res.error?.message || "Failed to update memory");
+      return res.data;
+    },
+    // Delete an entry
+    async delete(key) {
+      const res = await authFetch2("/v1/memory/" + encodeURIComponent(key), { method: "DELETE" });
+      if (!res.ok) throw new Error(res.error?.message || "Failed to delete memory");
+      return res.data;
+    },
+    /**
+     * List memory keys.
+     *
+     * opts:
+     *   prefix, visibility, tags   — as before
+     *   agent      — list ONE of the owner's agents' namespaces (full GAII `name#owner@node`)
+     *   ownerScope — list across the owner's GHII + every same-owner agent. An owner session
+     *                already gets this server-side; an app-grant token needs it stated.
+     *   meta       — omit every `value` and report each entry's `bytes` instead. Use this for
+     *                any listing you render as a table/board: the default response inlines
+     *                every value, so a fleet-wide prefix can be megabytes per call.
+     *   count      — return only `{ count }` (server-side COUNT, no values). A cheap
+     *                "did anything change?" probe; its cache is dropped by any memory write.
+     */
+    async list(opts) {
+      const params = scopeParams(opts);
+      if (opts?.prefix) params.set("prefix", opts.prefix);
+      if (opts?.visibility) params.set("visibility", opts.visibility);
+      if (opts?.tags) params.set("tags", opts.tags.join(","));
+      if (opts?.meta) params.set("include", "meta");
+      if (opts?.count) params.set("count", "true");
+      const qs = params.toString();
+      const res = await authFetch2("/v1/memory" + (qs ? "?" + qs : ""));
+      if (!res.ok) throw new Error(res.error?.message || "Failed to list memory");
+      return res.data;
+    },
+    /** Cheap change probe: the number of keys under a prefix, no values transferred. */
+    async count(opts) {
+      const d = await data.list({ ...opts || {}, count: true });
+      return d && typeof d.count === "number" ? d.count : null;
+    },
+    // Search memory entries
+    // opts: { visibility, agent, ownerScope } — scoping as in list().
+    async search(query, opts) {
+      const params = scopeParams(opts);
+      params.set("q", query);
+      if (opts?.visibility) params.set("visibility", opts.visibility);
+      const res = await authFetch2("/v1/memory/search?" + params.toString());
+      if (!res.ok) throw new Error(res.error?.message || "Failed to search memory");
+      return res.data;
+    },
+    // Read another agent's public memory (no auth needed). ?soft=1: missing (or hidden)
+    // keys resolve null via a clean 200 instead of logging a console 404.
+    async getPublic(gaii, key) {
+      const url = NODE_URL + "/v1/memory/" + encodeURIComponent(gaii) + "/" + encodeURIComponent(key) + "?soft=1";
+      const r = await fetch(url);
+      const res = await r.json();
+      if (!res.ok) {
+        if (res.error?.code === "NOT_FOUND") return null;
+        throw new Error(res.error?.message || "Failed to read public memory");
+      }
+      return res.data.value;
+    },
+    // ── Micro-Memory (Tier 0.5, GET-based) ──
+    micro(setName, accessCode) {
+      const base = NODE_URL + "/v1/mm";
+      function mmUrl(params) {
+        const p = new URLSearchParams(params);
+        if (accessCode) p.set("access_code", accessCode);
+        return base + "?" + p.toString();
+      }
+      async function mmFetch(params) {
+        const r = await fetch(mmUrl(params));
+        const res = await r.json();
+        if (!res.ok) throw new Error(res.error?.message || "Micro-memory operation failed");
+        return res.data;
+      }
+      return {
+        // Add or overwrite a key
+        async add(key, value) {
+          return mmFetch({ op: "add", set: setName, key, value: typeof value === "object" ? JSON.stringify(value) : String(value) });
+        },
+        // Modify existing key
+        async mod(key, value) {
+          return mmFetch({ op: "mod", set: setName, key, value: typeof value === "object" ? JSON.stringify(value) : String(value) });
+        },
+        // Delete a key
+        async del(key) {
+          return mmFetch({ op: "del", set: setName, key });
+        },
+        // List all entries in this set
+        async list() {
+          return mmFetch({ op: "list", set: setName });
+        },
+        // Batch add multiple key-value pairs
+        async batch(entries) {
+          const params = { op: "batch", set: setName };
+          Object.keys(entries).forEach((k, i) => {
+            params["key" + i] = k;
+            const v = entries[k];
+            params["value" + i] = typeof v === "object" ? JSON.stringify(v) : String(v);
+          });
+          return mmFetch(params);
+        },
+        // Configure visibility
+        async config(visibility) {
+          const params = { op: "config", set: setName, access: visibility };
+          return mmFetch(params);
+        },
+        // Get a single key value
+        async get(key) {
+          const d = await mmFetch({ op: "list", set: setName });
+          return d.entries?.[key] ?? null;
+        }
+      };
+    },
+    // List all micro-memory sets
+    async microSets() {
+      const url = NODE_URL + "/v1/mm?op=list";
+      const r = await fetch(url);
+      const res = await r.json();
+      if (!res.ok) throw new Error(res.error?.message || "Failed to list micro-memory sets");
+      return res.data;
+    }
+  };
+  attach("data", data);
+})();