aimeat 2.1.0 → 2.2.0

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

@@ -238,12 +238,64 @@
       hadHiddenUpdate = false;
     }
   }
-  function subscribe(domains, fn) {
+  function subscribe(domains, fn, opts) {
     if (typeof domains === "function") {
+      opts = fn;
       fn = domains;
       domains = null;
     }
-    var entry = { domains: domains ? new Set(domains) : null, fn };
+    opts = opts || {};
+    var prefixes = opts.keyPrefix ? Array.isArray(opts.keyPrefix) ? opts.keyPrefix.slice() : [opts.keyPrefix] : null;
+    var minInterval = opts.minIntervalMs > 0 ? opts.minIntervalMs : 0;
+    var counts = /* @__PURE__ */ Object.create(null);
+    var lastCall = 0;
+    var probing = false;
+    var primed = !prefixes;
+    function pass(dset) {
+      lastCall = Date.now();
+      try {
+        fn(dset);
+      } catch {
+      }
+    }
+    function gate(dset) {
+      if (minInterval && Date.now() - lastCall < minInterval) return;
+      if (!prefixes) {
+        pass(dset);
+        return;
+      }
+      if (probing) return;
+      probing = true;
+      Promise.all(prefixes.map(function(p) {
+        var qs = "count=true&prefix=" + encodeURIComponent(p) + (opts.agent ? "&agent=" + encodeURIComponent(opts.agent) : opts.ownerScope ? "&owner_scope=true" : "");
+        return getSession2().fetch("/v1/memory?" + qs).then(function(r) {
+          var c = r && r.data && typeof r.data.count === "number" ? r.data.count : null;
+          return { prefix: p, count: c };
+        }).catch(function() {
+          return { prefix: p, count: null };
+        });
+      })).then(function(res) {
+        probing = false;
+        var changed = false;
+        res.forEach(function(r) {
+          if (r.count == null) return;
+          if (counts[r.prefix] !== r.count) {
+            changed = true;
+            counts[r.prefix] = r.count;
+          }
+        });
+        if (!primed) {
+          primed = true;
+          if (res.every(function(r) {
+            return r.count != null;
+          })) return;
+        }
+        if (changed) pass(dset);
+      }).catch(function() {
+        probing = false;
+      });
+    }
+    var entry = { domains: domains ? new Set(domains) : null, fn: gate };
     subscribers.push(entry);
     connect();
     return function() {

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

@@ -598,5 +598,36 @@
     (document.head || document.documentElement).appendChild(s);
   }
   injectCss();
-  attach("md", { render, renderToString, renderRich, sanitizeHref, sanitizeImgSrc });
+  var CITE_URL_RE = /https?:\/\/[^\s,;)\]}"'【】]+/g;
+  var SHORTENERS = ["lnkd.in", "bit.ly", "t.co", "ow.ly", "tinyurl.com", "buff.ly", "goo.gl", "is.gd", "rb.gy"];
+  function citations(text, opts) {
+    var strip = !opts || opts.stripInline !== false;
+    var body = String(text == null ? "" : text);
+    var seen = /* @__PURE__ */ Object.create(null);
+    var out = [];
+    function push(u) {
+      u = String(u).replace(/[.,;:]+$/, "");
+      if (!u || seen[u]) return;
+      seen[u] = 1;
+      var host;
+      try {
+        host = new URL(u).hostname.replace(/^www\./, "");
+      } catch {
+        host = "";
+      }
+      out.push({ url: u, host, shortened: SHORTENERS.indexOf(host) >= 0 });
+    }
+    body = body.replace(/【\s*(https?:\/\/[^】\s]+)\s*】/g, function(m, u) {
+      push(u);
+      return strip ? "" : m;
+    });
+    body = body.replace(/^[ \t]*Sources?[ \t]*:[ \t]*(.*)$/gim, function(m, rest) {
+      (String(rest).match(CITE_URL_RE) || []).forEach(push);
+      return strip ? "" : m;
+    });
+    (body.match(CITE_URL_RE) || []).forEach(push);
+    if (strip) body = body.replace(/[ \t]+$/gm, "").replace(/\n{3,}/g, "\n\n").trim();
+    return { body, sources: out };
+  }
+  attach("md", { render, renderToString, renderRich, sanitizeHref, sanitizeImgSrc, citations });
 })();

package/dist/static/sdk-libs/live/index.js

@@ -13,6 +13,10 @@
  *   const off = AIMEAT.live.subscribe(['agent-tasks','organisms'], (domains) => reload());
  * @version-history
  *   v1.0.0 — 2026-07-19 — Migrated from src/routes/lib-live.ts (SDK-libs migration Phase 1).
+ *   v1.1.0 — 2026-07-25 — subscribe() takes a third options argument: { keyPrefix, agent, ownerScope,
+ *     minIntervalMs }. On a multi-agent fleet the 'memory' domain fires continuously, so every
+ *     subscriber effectively polled. keyPrefix gates on a cheap server-side COUNT (the change frame
+ *     carries no key, so a new key is detected and an in-place update is not). Additive.
  */
 import { makeSession } from '../_core/session.js';
 const { getSession } = makeSession('aimeat-live.js');
@@ -136,10 +140,73 @@ function disconnect() {
   }
 }
 
-// Subscribe to specific domains (or null = all). Auto-connects on first subscribe. Returns unsubscribe.
-function subscribe(domains, fn) {
-  if (typeof domains === 'function') { fn = domains; domains = null; }
-  var entry = { domains: domains ? new Set(domains) : null, fn: fn };
+/**
+ * Subscribe to specific domains (or null = all). Auto-connects on first subscribe.
+ * Returns an unsubscribe function.
+ *
+ * opts (all optional, all additive — a two-argument call behaves exactly as before):
+ *   keyPrefix    — string | string[]. Only fire when the number of the caller's memory keys
+ *                  under one of these prefixes has CHANGED since the last check. The server's
+ *                  change frame carries a domain name only (see services/event-bus.ts), never
+ *                  the key that changed, so this is a client-side gate: on each 'memory' event
+ *                  the lib asks for a cheap server-side COUNT (`?count=true`, no values, its
+ *                  cache invalidated by any write) and stays quiet when the count is unmoved.
+ *                  LIMITATION, by design of the frame: a NEW key is detected, an in-place
+ *                  UPDATE of an existing key is not. For update-sensitive views pass
+ *                  minIntervalMs instead of (or with) keyPrefix.
+ *   agent        — GAII to scope the count to one agent's namespace.
+ *   ownerScope   — count across the owner's GHII + agents (an app-grant token needs this).
+ *   minIntervalMs— never invoke the callback more often than this. On a fleet with many agents
+ *                  the 'memory' domain is a firehose; this is the blunt version of the gate.
+ *
+ * Why this exists: a multi-agent owner writes memory constantly, so `subscribe(['memory'], reload)`
+ * fires more or less continuously, and every subscriber that re-fetched a full listing on each
+ * event turned one agent's activity into a permanent poll.
+ */
+function subscribe(domains, fn, opts) {
+  if (typeof domains === 'function') { opts = fn; fn = domains; domains = null; }
+  opts = opts || {};
+  var prefixes = opts.keyPrefix
+    ? (Array.isArray(opts.keyPrefix) ? opts.keyPrefix.slice() : [opts.keyPrefix])
+    : null;
+  var minInterval = opts.minIntervalMs > 0 ? opts.minIntervalMs : 0;
+  var counts = Object.create(null);   // prefix -> last seen count
+  var lastCall = 0;
+  var probing = false;
+  var primed = !prefixes;             // with keyPrefix, the first event only records a baseline
+
+  function pass(dset) { lastCall = Date.now(); try { fn(dset); } catch { /* subscriber threw */ } }
+
+  function gate(dset) {
+    if (minInterval && (Date.now() - lastCall) < minInterval) return;
+    if (!prefixes) { pass(dset); return; }
+    if (probing) return;              // one probe in flight is enough
+    probing = true;
+    Promise.all(prefixes.map(function (p) {
+      var qs = 'count=true&prefix=' + encodeURIComponent(p) +
+        (opts.agent ? '&agent=' + encodeURIComponent(opts.agent)
+          : (opts.ownerScope ? '&owner_scope=true' : ''));
+      return getSession().fetch('/v1/memory?' + qs)
+        .then(function (r) {
+          var c = r && r.data && typeof r.data.count === 'number' ? r.data.count : null;
+          return { prefix: p, count: c };
+        })
+        .catch(function () { return { prefix: p, count: null }; });
+    })).then(function (res) {
+      probing = false;
+      var changed = false;
+      res.forEach(function (r) {
+        if (r.count == null) return;                 // probe failed: do not claim a change
+        if (counts[r.prefix] !== r.count) { changed = true; counts[r.prefix] = r.count; }
+      });
+      // A failed/unavailable probe must not silence a real update forever: if we could not
+      // establish any baseline, fall through and let the subscriber decide.
+      if (!primed) { primed = true; if (res.every(function (r) { return r.count != null; })) return; }
+      if (changed) pass(dset);
+    }).catch(function () { probing = false; });
+  }
+
+  var entry = { domains: domains ? new Set(domains) : null, fn: gate };
   subscribers.push(entry);
   connect();
   return function () {

package/dist/static/sdk-libs/markdown/index.js

@@ -14,6 +14,10 @@
  * @usage <script src="/v1/libs/aimeat-markdown.js"></script>  AIMEAT.md.render(md, '#out')
  * @version-history
  *   v1.0.0 — 2026-07-19 — Migrated from src/routes/lib-markdown.ts (SDK-libs migration Phase 2).
+ *   v1.1.0 — 2026-07-25 — Added AIMEAT.md.citations(text): pulls `Source:`/`Sources:` lines, inline
+ *     lenticular 【url】 citations and bare URLs out of LLM prose into one source list (host +
+ *     shortener flag). Every app rendering agent output had hand-rolled this, and the hand-rolled
+ *     URL regexes kept including the closing 】 in the href.
  */
 import { NODE_URL } from '../_core/config.js';
 import { attach } from '../_core/namespace.js';
@@ -519,4 +523,48 @@ function injectCss() {
 }
 injectCss();
 
-attach('md', { render: render, renderToString: renderToString, renderRich: renderRich, sanitizeHref: sanitizeHref, sanitizeImgSrc: sanitizeImgSrc });
+// ── citations ───────────────────────────────────────────────────────────────
+// LLM-written prose cites its sources in at least three conventions, often mixed
+// inside ONE document: a trailing `Source:`/`Sources:` line, inline lenticular
+// 【https://…】 brackets (a model artifact no markdown renderer linkifies, so it
+// renders as literal junk), and bare inline URLs. Every app that displays agent
+// output re-invented this parse, and the hand-rolled URL regexes kept forgetting
+// to exclude 】 — which silently puts the bracket inside the href and breaks the
+// link. One implementation, here, next to the renderer that consumes it.
+var CITE_URL_RE = /https?:\/\/[^\s,;)\]}"'【】]+/g;
+
+// Link shorteners hide their destination, so a UI cannot show a trustworthy
+// publisher name for them. Reported separately rather than silently.
+var SHORTENERS = ['lnkd.in', 'bit.ly', 't.co', 'ow.ly', 'tinyurl.com', 'buff.ly', 'goo.gl', 'is.gd', 'rb.gy'];
+
+/**
+ * Split cited sources out of prose.
+ * @param {string} text
+ * @param {{stripInline?: boolean}} [opts] stripInline (default true): remove the
+ *   bracketed/trailing citation noise from `body`. Bare inline URLs are left in place.
+ * @returns {{body: string, sources: Array<{url: string, host: string, shortened: boolean}>}}
+ */
+function citations(text, opts) {
+  var strip = !opts || opts.stripInline !== false;
+  var body = String(text == null ? '' : text);
+  var seen = Object.create(null);
+  var out = [];
+  function push(u) {
+    u = String(u).replace(/[.,;:]+$/, '');
+    if (!u || seen[u]) return;
+    seen[u] = 1;
+    var host;
+    try { host = new URL(u).hostname.replace(/^www\./, ''); } catch { host = ''; }
+    out.push({ url: u, host: host, shortened: SHORTENERS.indexOf(host) >= 0 });
+  }
+  body = body.replace(/【\s*(https?:\/\/[^】\s]+)\s*】/g, function (m, u) { push(u); return strip ? '' : m; });
+  body = body.replace(/^[ \t]*Sources?[ \t]*:[ \t]*(.*)$/gim, function (m, rest) {
+    (String(rest).match(CITE_URL_RE) || []).forEach(push);
+    return strip ? '' : m;
+  });
+  (body.match(CITE_URL_RE) || []).forEach(push);
+  if (strip) body = body.replace(/[ \t]+$/gm, '').replace(/\n{3,}/g, '\n\n').trim();
+  return { body: body, sources: out };
+}
+
+attach('md', { render: render, renderToString: renderToString, renderRich: renderRich, sanitizeHref: sanitizeHref, sanitizeImgSrc: sanitizeImgSrc, citations: citations });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aimeat",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "AIME AT - AI Memory Exchange and Action Transfer - reference implementation",
   "type": "module",
   "main": "dist/src/index.js",
@@ -178,6 +178,7 @@
     "typecheck:sdk": "tsc --noEmit -p tsconfig.sdk.json",
     "check:importmap": "tsx scripts/check-importmap.ts",
     "check:no-max-tokens": "tsx scripts/check-no-max-tokens.ts",
+    "check:openapi": "tsx scripts/check-openapi.ts",
     "screenshot:worker": "tsx scripts/screenshot-worker.ts",
     "generate:types": "openapi-typescript ../openapi.yaml -o src/generated/api-types.ts",
     "db:reset": "node --env-file=.env --import tsx scripts/db-reset.ts",
@@ -195,6 +196,9 @@
     "audit:mcp-schemas": "tsx scripts/audit-mcp-schemas.ts",
     "eval:mcp-surface": "tsx test/eval-mcp/surface-weight.ts",
     "perf:bench": "node --import tsx tools/perf-bench/bench.ts",
-    "perf:bench:backends": "node --import tsx tools/perf-bench/bench-backends.ts"
+    "perf:bench:backends": "node --import tsx tools/perf-bench/bench-backends.ts",
+    "sync:viewport": "tsx scripts/embed-viewport.ts",
+    "check:viewport": "tsx scripts/embed-viewport.ts --check",
+    "check:theme": "tsx tools/theme-contrast.ts"
   }
 }