aimeat 2.1.0 → 2.2.0

package/dist/static/sdk-libs/auth/pill.js

@@ -10,11 +10,17 @@
  * @structure mountPill(auth, selector, opts) → render() + event wiring.
  * @usage import { mountPill } from './pill.js';  (auth.mountLoginButton delegates here)
  * @version-history
+ *   v1.1.0 — 2026-07-25 — The in-pill controls become the platform control cluster (segmented
+ *     language switch + segmented ☀|☾ mode switch + palette swatch picker, styled by cluster.js),
+ *     with outside-click/Escape closers for the cluster popovers.
  *   v1.0.0 — 2026-07-19 — Extracted from src/routes/libs/auth-lib-part2.ts (SDK-libs migration Phase 3).
  */
 import { isAppOrigin, restoreSessionFromAppOrigin } from './session.js';
 import { showLoginModal } from './modal.js';
-import { escHtml, themeToggleHtml, wireThemeToggle, ensureAuthPillStyles, pillInitials } from './theme.js';
+import { escHtml, modeSwitchHtml, wireModeSwitch, ensureAuthPillStyles, pillInitials } from './theme.js';
+import { readLocales, langSwitchHtml, wireLangSwitch } from './locale.js';
+import { paletteControlHtml, wirePaletteControl } from './palette.js';
+import { ensureClusterStyles, clampPopover } from './cluster.js';
 import { load, remove } from './crypto.js';
 import { emit } from './events.js';
 
@@ -34,6 +40,9 @@ export function mountPill(auth, selector, opts = {}) {
   }
 
   const i = opts.i18n || {};
+  // Languages the APP says it has: opts.locales, else <meta name="aimeat-locales" content="en fi">.
+  // Empty when the app declares none or only one, and then no language control renders at all.
+  const locales = readLocales(opts);
   // Compact pill (account button + popover on ≤600px) is the mobile-safe DEFAULT on app origins.
   const useCompact = opts.compact !== undefined ? !!opts.compact : isAppOrigin();
 
@@ -66,8 +75,9 @@ export function mountPill(auth, selector, opts = {}) {
             + 'background:rgba(90,65,20,.18);color:#5a4114;border:1px solid rgba(120,85,20,.35);'
             + 'border-radius:6px;padding:3px 8px;cursor:pointer;font-size:13px;line-height:1">⚙️</button>'
           : '')
-        // Light/dark toggle — lives inside the pill so embedding apps inherit it for free.
-        + themeToggleHtml(i)
+        // The control cluster — language, light/dark mode, palette — inside the pill so every
+        // embedding app inherits the SAME three controls for free.
+        + '<span class="aimeat-ctl">' + langSwitchHtml(i, locales) + modeSwitchHtml(i) + paletteControlHtml(i) + '</span>'
         + '<button id="aimeat-logout-btn" class="aimeat-auth-logout" style="'
         + 'background:radial-gradient(ellipse at 50% 30%,#ff6b6b 0%,#dc2626 35%,#991b1b 70%,#7f1d1d 100%);'
         + 'color:#ffd7d7;border:1px solid rgba(220,38,38,.6);border-top-color:rgba(255,130,130,.4);border-bottom-color:rgba(100,20,20,.8);'
@@ -121,9 +131,9 @@ export function mountPill(auth, selector, opts = {}) {
         + 'transition:transform .15s,box-shadow .15s}'
         + '.aimeat-sign-btn:hover{transform:translateY(-1px);box-shadow:0 1px 0 rgba(245,230,163,.3) inset,0 -1px 0 rgba(75,53,32,.5) inset,0 5px 16px rgba(0,0,0,.5),0 0 30px rgba(201,168,76,.3)}'
         + '</style>'
-        // Keep the light/dark toggle reachable even when signed out.
+        // Keep the whole cluster (language + mode + palette) reachable even when signed out.
         + '<span style="display:inline-flex;align-items:center;gap:10px">'
-        + themeToggleHtml(i)
+        + '<span class="aimeat-ctl">' + langSwitchHtml(i, locales) + modeSwitchHtml(i) + paletteControlHtml(i) + '</span>'
         + '<button id="aimeat-login-btn" class="aimeat-sign-btn">'
         + (opts.buttonText || i.signInBtn || '❤️ Sign In') + '</button>'
         + '</span>';
@@ -134,9 +144,30 @@ export function mountPill(auth, selector, opts = {}) {
         else { showLoginModal(opts, render); }
       });
     }
-    wireThemeToggle(container, i); // present in both signed-in and signed-out markup
+    wireModeSwitch(container); // the cluster is present in both signed-in and signed-out markup
+    wireLangSwitch(container, i, locales);
+    wirePaletteControl(container, clampPopover);
   }
+  ensureClusterStyles();
   render();
+  // Close any open cluster popover (palette / language list) on an outside click or Escape.
+  document.addEventListener('click', (ev) => {
+    container.querySelectorAll('.aimeat-pop-wrap.aimeat-open').forEach((w) => {
+      if (!w.contains(/** @type {Node} */ (ev.target))) {
+        w.classList.remove('aimeat-open');
+        var b = w.querySelector('.aimeat-pop-btn');
+        if (b) b.setAttribute('aria-expanded', 'false');
+      }
+    });
+  });
+  document.addEventListener('keydown', (ev) => {
+    if (ev.key !== 'Escape') return;
+    container.querySelectorAll('.aimeat-pop-wrap.aimeat-open').forEach((w) => {
+      w.classList.remove('aimeat-open');
+      var b = w.querySelector('.aimeat-pop-btn');
+      if (b) b.setAttribute('aria-expanded', 'false');
+    });
+  });
   // Close the compact popover on an outside click or Escape (registered ONCE per mount).
   if (useCompact) {
     var closeCompact = () => {

package/dist/static/sdk-libs/auth/theme.js

@@ -5,10 +5,15 @@
  *   writes the same 'aimeat-theme' localStorage key + <html data-theme> the SPA uses, and fires an
  *   'aimeat-theme-change' window event), plus escHtml, the compact-pill CSS injector, and the
  *   two-letter pill initials. Extracted from auth-lib-part2.ts.
- * @structure escHtml · aimeatReadTheme/aimeatApplyTheme · themeToggleHtml/wireThemeToggle ·
+ * @structure escHtml · aimeatReadTheme/aimeatApplyTheme · modeSwitchHtml/wireModeSwitch ·
  *   ensureAuthPillStyles · pillInitials.
- * @usage import { escHtml, themeToggleHtml, wireThemeToggle } from './theme.js';
+ * @usage import { escHtml, modeSwitchHtml, wireModeSwitch } from './theme.js';
  * @version-history
+ *   v1.2.0 — 2026-07-26 — ?mode= is read first and applied at parse time (aimeatRestoreMode), the
+ *     same door ?palette= and ?lang= use, so an embedded app follows the embedding page's light/
+ *     dark instead of its own origin's storage. Not persisted.
+ *   v1.1.0 — 2026-07-25 — The lone ☾/☀ toggle becomes a segmented ☀|☾ mode switch (both options
+ *     visible, active marked), styled by cluster.js instead of inline styles.
  *   v1.0.0 — 2026-07-19 — Extracted from src/routes/libs/auth-lib-part2.ts (SDK-libs migration Phase 3).
  */
 
@@ -18,6 +23,13 @@ export function escHtml(s) { const d = document.createElement('div'); d.textCont
 var AIMEAT_THEME_KEY = 'aimeat-theme';
 
 export function aimeatReadTheme() {
+  // ?mode= first, the same door ?palette= and ?lang= use: an app embedded by another page cannot
+  // read the choice made on the embedder's origin, so the embedder says it and the app follows.
+  // Deliberately not persisted — being embedded in a dark page is not a decision about the app.
+  try {
+    var u = new URLSearchParams(location.search).get('mode');
+    if (u === 'light' || u === 'dark') return u;
+  } catch { /* no location */ }
   try { var s = localStorage.getItem(AIMEAT_THEME_KEY); if (s === 'light' || s === 'dark') return s; } catch { /* storage blocked */ }
   var attr = document.documentElement.dataset.theme;
   if (attr === 'light' || attr === 'dark') return attr;
@@ -30,26 +42,55 @@ export function aimeatApplyTheme(t) {
   try { window.dispatchEvent(new CustomEvent('aimeat-theme-change', { detail: { theme: t } })); } catch { /* no window */ }
 }
 
-export function themeToggleHtml(i) {
-  var dark = aimeatReadTheme() === 'dark';
-  var title = dark ? (i.themeToLight || 'Switch to light mode') : (i.themeToDark || 'Switch to dark mode');
-  return '<button id="aimeat-theme-toggle" class="aimeat-theme-toggle" title="' + escHtml(title) + '" '
-    + 'aria-label="' + escHtml(title) + '" style="display:inline-flex;align-items:center;justify-content:center;'
-    + 'width:30px;height:30px;flex:0 0 auto;background:transparent;border:1px solid rgba(127,127,127,.4);'
-    + 'border-radius:8px;cursor:pointer;font-size:15px;line-height:1;padding:0;color:currentColor">'
-    + (dark ? '☀' : '☾') + '</button>';
+/**
+ * Adopt an embedder's ?mode= onto <html> at parse time, without persisting it. The app's own
+ * light/dark snippet reads localStorage and cannot know it is inside someone else's page; this
+ * runs after it and lets the embedding page win for as long as the embed lasts. No URL param
+ * means no opinion, so a normally-opened app is untouched.
+ */
+export function aimeatRestoreMode() {
+  try {
+    var u = new URLSearchParams(location.search).get('mode');
+    if (u === 'light' || u === 'dark') document.documentElement.dataset.theme = u;
+  } catch { /* no location */ }
 }
 
-export function wireThemeToggle(container, i) {
-  var btn = container.querySelector('#aimeat-theme-toggle');
-  if (!btn) return;
-  btn.addEventListener('click', function () {
-    var next = aimeatReadTheme() === 'dark' ? 'light' : 'dark';
-    aimeatApplyTheme(next);
-    var dark = next === 'dark';
-    btn.textContent = dark ? '☀' : '☾';
-    var title = dark ? (i.themeToLight || 'Switch to light mode') : (i.themeToDark || 'Switch to dark mode');
-    btn.title = title; btn.setAttribute('aria-label', title);
+/**
+ * The MODE control: a segmented ☀ | ☾ where both options are visible and the active one is
+ * marked — the same pattern as the language switch, so the cluster reads as one instrument.
+ * Cluster classes come from cluster.js (ensureClusterStyles).
+ */
+export function modeSwitchHtml(i) {
+  var cur = aimeatReadTheme();
+  var light = i.lightMode || 'Light mode';
+  var dark = i.darkMode || 'Dark mode';
+  return '<span id="aimeat-mode-switch" class="aimeat-seg" role="group" aria-label="' + escHtml(i.themeLabel || 'Theme') + '">'
+    + '<button type="button" data-mode="light" aria-pressed="' + (cur === 'light') + '" title="' + escHtml(light) + '" aria-label="' + escHtml(light) + '">'
+    + '<span class="seg-ico" aria-hidden="true">☀</span></button>'
+    + '<button type="button" data-mode="dark" aria-pressed="' + (cur === 'dark') + '" title="' + escHtml(dark) + '" aria-label="' + escHtml(dark) + '">'
+    + '<span class="seg-ico" aria-hidden="true">☾</span></button>'
+    + '</span>';
+}
+
+export function wireModeSwitch(container) {
+  var root = container.querySelector('#aimeat-mode-switch');
+  if (!root) return;
+  function sync(cur) {
+    root.querySelectorAll('button[data-mode]').forEach(function (b) {
+      b.setAttribute('aria-pressed', String(b.getAttribute('data-mode') === cur));
+    });
+  }
+  root.querySelectorAll('button[data-mode]').forEach(function (b) {
+    b.addEventListener('click', function () {
+      var m = b.getAttribute('data-mode');
+      aimeatApplyTheme(m);
+      sync(m);
+    });
+  });
+  // Follow out-of-band changes (the app's own logic, another control instance, the SPA).
+  window.addEventListener('aimeat-theme-change', function (ev) {
+    var e = /** @type {CustomEvent} */ (ev);
+    if (e && e.detail && e.detail.theme) sync(e.detail.theme);
   });
 }
 

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

@@ -13,12 +13,44 @@
  *   await AIMEAT.data.set('key', { value }); await AIMEAT.data.get('key');
  * @version-history
  *   v1.0.0 — 2026-07-19 — Migrated from src/routes/lib-data.ts; NODE_URL/NODE_ID now from _core/config.
+ *   v1.1.0 — 2026-07-25 — Cross-namespace reads: get/getEntry/list/search take { agent, ownerScope };
+ *     list takes { meta, count } (+ data.count()). Agent-published keys live under the agent's GAII,
+ *     and an app-grant token gets no automatic owner-scope broadening, so apps had to bypass this
+ *     library entirely to read their own owner's fleet output. All options are additive.
  */
 import { NODE_URL, NODE_ID } from '../_core/config.js';
 import { makeSession } from '../_core/session.js';
 const { authFetch } = makeSession('aimeat-data.js');
 import { attach } from '../_core/namespace.js';
 
+/**
+ * Cross-namespace read scoping, shared by get/getEntry/list/search.
+ *
+ * Agents publish under their OWN namespace (`name#owner@node`), not the owner's GHII.
+ * An owner SESSION gets owner-scope broadening automatically server-side, but an
+ * app-grant token (roles:['app']) does not — so an app reading its owner's fleet
+ * output must say so explicitly. Before these options the only way to do that was
+ * to bypass this library and hand-roll session.fetch calls.
+ *
+ * @param {{agent?: string, ownerScope?: boolean}} [opts]
+ * @returns {URLSearchParams}
+ */
+function scopeParams(opts) {
+  const p = new URLSearchParams();
+  if (opts?.agent) p.set('agent', opts.agent);
+  // `agent` already targets one namespace; sending both is contradictory (the server
+  // ignores owner_scope when agent is present), so only one goes on the wire.
+  else if (opts?.ownerScope) p.set('owner_scope', 'true');
+  return p;
+}
+
+/** Append params to a path, preserving any query string already on it. */
+function withParams(path, params) {
+  const qs = params.toString();
+  if (!qs) return path;
+  return path + (path.indexOf('?') >= 0 ? '&' : '?') + qs;
+}
+
 // ── Memory API (Tier 1, JWT auth) ──
 
 const data = {
@@ -33,11 +65,17 @@ const 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.
-  async get(key) {
-    const res = await authFetch('/v1/memory/' + encodeURIComponent(key) + '?soft=1');
+  // 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 authFetch(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;
+    // A scoped read is explicit about where to look; do not silently widen it to the
+    // app-creator's public namespace.
+    if (opts?.agent || opts?.ownerScope) return val;
     // Fallback: try public read from app creator's namespace
     var creator = document.querySelector('meta[name="aimeat-creator"]')?.getAttribute('content');
     if (!creator) {
@@ -56,9 +94,10 @@ const data = {
     return val;
   },
 
-  // Read full entry metadata
-  async getEntry(key) {
-    const res = await authFetch('/v1/memory/' + encodeURIComponent(key));
+  // Read full entry metadata. opts: { agent, ownerScope } as in get().
+  async getEntry(key, opts) {
+    const res = await authFetch(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');
@@ -83,21 +122,44 @@ const data = {
     return res.data;
   },
 
-  // List all memory keys
+  /**
+   * 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 = new URLSearchParams();
+    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 authFetch('/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 = new URLSearchParams({ q: query });
+    const params = scopeParams(opts);
+    params.set('q', query);
     if (opts?.visibility) params.set('visibility', opts.visibility);
     const res = await authFetch('/v1/memory/search?' + params.toString());
     if (!res.ok) throw new Error(res.error?.message || 'Failed to search memory');

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

@@ -70,7 +70,14 @@
       }) || null;
     },
     /** Commission a task for an agent. Returns the created task ({ id, status, ... }).
-     *  Created 'queued' by default; task-runner agents auto-activate it. */
+     *  Created 'queued' by default; task-runner agents auto-activate it.
+     *
+     *  task.scope: [{ name, value, type }] — app-defined tags stored ON the task. This is how
+     *  an app finds its own runs again later: filter `tasks({status:'done'})` on a tag you set,
+     *  instead of trying to parse the agent's memory-key slug. Pass the same array in a
+     *  schedule's `task_template.scope` so scheduled runs carry it too.
+     *  task.verification: { user_expects, technical_checks } — what a good result looks like.
+     *  Both were silently dropped before v1.1.0. */
     async createTask(name, task) {
       if (!task || !task.description) throw new Error("createTask requires { description }");
       var body = {
@@ -78,6 +85,25 @@
         description: task.description,
         status: task.status || "queued"
       };
+      if (Array.isArray(task.scope) && task.scope.length) {
+        body.scope = task.scope.map(function(s) {
+          return {
+            name: s.name,
+            value: String(s.value),
+            type: s.type || "text",
+            ...s.description ? { description: s.description } : {}
+          };
+        });
+      }
+      if (task.verification) {
+        var v = task.verification;
+        body.verification = {
+          user_expects: v.user_expects != null ? v.user_expects : v.userExpects || "",
+          technical_checks: v.technical_checks || v.technicalChecks || []
+        };
+      }
+      if (task.rules) body.rules = task.rules;
+      if (task.resources) body.resources = task.resources;
       var data = unwrap(await authFetch2("/v1/agents/" + enc(name) + "/tasks", {
         method: "POST",
         body: JSON.stringify(body)
@@ -143,14 +169,21 @@
      *  agent's memory. Returns { key, value } | { key, gone:true } | null. */
     async deliverable(name, id) {
       var task = await agents.getTask(name, id);
-      var key = task && task.deliverableKey;
-      if (!key) return null;
-      var data = unwrap(await authFetch2("/v1/memory?agent=" + enc(task.agentGaii) + "&prefix=" + enc(key) + "&per_page=20"), "read deliverable");
-      var items = data.items || [];
-      var found = items.find(function(i) {
-        return i.key === key;
+      if (!task) return null;
+      var key = task.deliverableKey;
+      if (key) {
+        var data = unwrap(await authFetch2("/v1/memory?agent=" + enc(task.agentGaii) + "&prefix=" + enc(key) + "&per_page=20"), "read deliverable");
+        var found = (data.items || []).find(function(i) {
+          return i.key === key;
+        });
+        return found ? { key, value: found.value } : { key, gone: true };
+      }
+      var byTag = unwrap(await authFetch2("/v1/memory?agent=" + enc(task.agentGaii) + "&tags=" + enc("task:" + id) + "&per_page=20"), "read deliverable by tag");
+      var items = (byTag.items || []).slice().sort(function(a, b) {
+        return String(b.updated_at || "").localeCompare(String(a.updated_at || ""));
       });
-      return found ? { key, value: found.value } : { key, gone: true };
+      if (items.length) return { key: items[0].key, value: items[0].value, viaTag: true };
+      return null;
     },
     /** Read a specific memory entry under an agent's namespace (or null). */
     async memory(name, key) {