@myvillage/cli 2.15.0 → 2.16.1

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@myvillage/cli",
-  "version": "2.15.0",
+  "version": "2.16.1",
   "description": "MyVillageOS CLI for community developers",
   "type": "module",
   "bin": {
     "myvillage": "./bin/myvillage.js"
   },
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
   "engines": {
     "node": ">=22.0.0"
   },

package/src/agent-runtime/context.js

@@ -14,13 +14,26 @@
 import { listDatasets } from '../utils/dataset-workspace.js';
 import { listModels } from '../utils/model-workspace.js';
 import { readAgentModels, describeAgentModel } from '../utils/agent-models.js';
+import { fetchAgentMemories, formatMemorySection, readEnvSecrets } from './memory-context.js';
 
-export async function gatherContext(agentConfig, lastCheckIn, recentActions = [], agentName = agentConfig?.name) {
+// `opts.agentDir` lets saved notes be checked against the agent's .env so a
+// secret never reaches the context; `opts.listMemory` swaps the memory fetch
+// (tests).
+export async function gatherContext(agentConfig, lastCheckIn, recentActions = [], agentName = agentConfig?.name, opts = {}) {
   const parts = [];
 
   parts.push(`Current time: ${new Date().toISOString()}`);
   parts.push(`Last check-in: ${lastCheckIn || 'never'}`);
 
+  // What the agent saved in earlier runs. Read by the runtime every loop, not
+  // left to the model to look up. Empty (and silent) if it can't be fetched.
+  const memories = await fetchAgentMemories(
+    agentConfig?.man?.agent_id,
+    opts.listMemory ? { list: opts.listMemory } : undefined,
+  );
+  const memorySection = formatMemorySection(memories, { secrets: readEnvSecrets(opts.agentDir) });
+  if (memorySection) parts.push(memorySection);
+
   // Include recent actions so the agent knows what it already did
   if (recentActions.length > 0) {
     parts.push('\nYour recent actions:');
@@ -76,5 +89,5 @@ export async function gatherContext(agentConfig, lastCheckIn, recentActions = []
   parts.push('You may post, comment, vote, read files, run your tools, or do nothing if appropriate.');
   parts.push('Be thoughtful — quality over quantity. Avoid repeating yourself.');
 
-  return { text: parts.join('\n') };
+  return { text: parts.join('\n'), memoryCount: memories.length };
 }

package/src/agent-runtime/loop.js

@@ -12,6 +12,7 @@ import { getMCPTools, cleanupMCPClients } from './mcp-client.js';
 import { getBuiltinTools } from './builtin-tools.js';
 import { readAgentModels } from '../utils/agent-models.js';
 import { gatherContext } from './context.js';
+import { RUN_NOTES_INSTRUCTION } from './memory-context.js';
 import { isWithinActiveHours, getNextCheckInMs } from './scheduler.js';
 import { parse as parseYaml } from 'yaml';
 import { postAgentHeartbeat, listAgentTasks, claimAgentTask, completeAgentTask, refreshAccessToken } from '../utils/api.js';
@@ -308,6 +309,10 @@ export async function agentLoop(agentName, { signal }) {
         logActivity(agentDir, { type: 'wisdom_loaded', count: wisdom.length, names: wisdom.map(w => w.name) });
       }
 
+      // Ask the agent to leave notes for its next run. Only when it can
+      // actually save them; the notes come back in the context every loop.
+      if (tools.agent_memory_set) systemPrompt = `${systemPrompt}\n\n${RUN_NOTES_INSTRUCTION}`;
+
       // Try to pull an assigned task first. Tasks take priority over ambient
       // feed-monitoring. If nothing is queued, fall through to the default.
       if (resuming) {
@@ -320,7 +325,7 @@ export async function agentLoop(agentName, { signal }) {
       // no longer auto-fetched here — the agent pulls them on demand via its
       // tools — so these activity counters stay at 0 unless a future signal
       // repopulates them.
-      const contextResult = await gatherContext(config, lastCheckIn, recentActions, agentName);
+      const contextResult = await gatherContext(config, lastCheckIn, recentActions, agentName, { agentDir });
       let context = contextResult.text;
       const eventsFound = 0;
 
@@ -360,6 +365,7 @@ Guidelines:
         feedItems: feedItemsRead,
         mentions: mentionsFound,
         events: eventsFound,
+        memories: contextResult.memoryCount,
       });
 
       const conversation = resuming

package/src/agent-runtime/memory-context.js

@@ -0,0 +1,136 @@
+// ── Memory Context ──────────────────────────────────────
+// Every loop starts a fresh conversation, so an agent forgets what it worked
+// out last run (a login selector that worked, an id it looked up) unless the
+// model happens to call agent_memory_list. Relying on that choice failed in
+// practice: an agent found the right selectors in run 1, never re-read them,
+// and spent run 2 guessing again.
+//
+// So the runtime reads the agent's saved memories itself, at the start of
+// every loop, and puts a compact "what you remember" section into the context.
+// It reads the same store the hosted agent_memory_* MCP tools use
+// (GET /api/network/agents/{agentProfileId}/memory), straight from the
+// platform API, so it works whether or not the agent was granted those tools.
+//
+// Notes saved under RUN_NOTES_CATEGORY are shown first: that is the category
+// the agent is asked to use for "things my next run should know".
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { listAgentMemory } from '../utils/api.js';
+
+export const RUN_NOTES_CATEGORY = 'run_notes';
+
+const DEFAULT_MAX_ENTRIES = 30;
+const DEFAULT_MAX_CHARS = 4000;
+const MAX_VALUE_CHARS = 500;
+const FETCH_TIMEOUT_MS = 8000;
+
+// Shown in the system prompt when the agent can call agent_memory_set. Kept
+// constant so it doesn't break the cached system-prompt prefix.
+export const RUN_NOTES_INSTRUCTION =
+  '## Notes for your next run\n' +
+  'Each run starts fresh: the only things you carry over are the notes you save. ' +
+  'Before you finish, if you worked something out that would save time next run (a selector, button or URL that worked, ' +
+  'an id you looked up, a step that failed and why), save it with agent_memory_set using ' +
+  `category "${RUN_NOTES_CATEGORY}" and a short descriptive key (e.g. "login_selectors"). ` +
+  'Update the same key rather than adding near-duplicates. ' +
+  'Never save a password or secret value; write its ${NAME} placeholder instead.';
+
+/**
+ * Fetch this agent's saved memories, newest first. Never throws: any failure
+ * (no agent id yet, offline, signed out, slow server) returns [] so the loop
+ * runs exactly as it did before.
+ */
+export async function fetchAgentMemories(agentId, { list = listAgentMemory, timeoutMs = FETCH_TIMEOUT_MS } = {}) {
+  if (!agentId) return [];
+  let timer;
+  try {
+    const res = await Promise.race([
+      list(agentId),
+      new Promise((resolve) => { timer = setTimeout(() => resolve(null), timeoutMs); }),
+    ]);
+    const entries = Array.isArray(res?.data) ? res.data : Array.isArray(res) ? res : [];
+    return entries.filter((e) => e && typeof e.key === 'string');
+  } catch {
+    return [];
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Values from the agent's .env, so a secret the agent mistakenly saved to
+ * memory is shown back as its ${NAME} placeholder instead of the real value.
+ */
+export function readEnvSecrets(agentDir) {
+  const out = [];
+  const path = agentDir && join(agentDir, '.env');
+  if (!path || !existsSync(path)) return out;
+  let text;
+  try { text = readFileSync(path, 'utf-8'); } catch { return out; }
+  for (const raw of text.split('\n')) {
+    const line = raw.trim();
+    if (!line || line.startsWith('#')) continue;
+    const eq = line.indexOf('=');
+    if (eq <= 0) continue;
+    const name = line.slice(0, eq).trim().replace(/^export\s+/, '');
+    let value = line.slice(eq + 1).trim();
+    if (value.length >= 2 && (value[0] === '"' || value[0] === "'") && value.endsWith(value[0])) {
+      value = value.slice(1, -1);
+    }
+    if (/^\w+$/.test(name) && value.length >= 3) out.push([name, value]);
+  }
+  // Longest first, so a value that contains another is replaced whole.
+  return out.sort((a, b) => b[1].length - a[1].length);
+}
+
+function redact(text, secrets) {
+  let out = text;
+  for (const [name, value] of secrets) out = out.split(value).join(`\${${name}}`);
+  return out;
+}
+
+function oneLine(value) {
+  const s = (typeof value === 'string' ? value : JSON.stringify(value) ?? '').replace(/\s+/g, ' ').trim();
+  return s.length > MAX_VALUE_CHARS ? `${s.slice(0, MAX_VALUE_CHARS)}…` : s;
+}
+
+function updatedTime(e) {
+  const t = Date.parse(e.updatedAt || e.createdAt || '');
+  return Number.isNaN(t) ? 0 : t;
+}
+
+/**
+ * Render memories as a compact context section, or '' when there are none.
+ * Run notes come first, then everything else; newest first within each, capped
+ * at `maxEntries` lines and roughly `maxChars` characters.
+ */
+export function formatMemorySection(
+  entries,
+  { maxEntries = DEFAULT_MAX_ENTRIES, maxChars = DEFAULT_MAX_CHARS, secrets = [] } = {},
+) {
+  if (!Array.isArray(entries) || entries.length === 0) return '';
+  const byNewest = [...entries].sort((a, b) => updatedTime(b) - updatedTime(a));
+  const ordered = [
+    ...byNewest.filter((e) => e.category === RUN_NOTES_CATEGORY),
+    ...byNewest.filter((e) => e.category !== RUN_NOTES_CATEGORY),
+  ];
+
+  const header = [
+    '\nWhat you remember from earlier runs (your own saved notes, newest first; use them instead of working things out again):',
+  ];
+  const lines = [];
+  let used = header[0].length;
+  for (const e of ordered) {
+    if (lines.length >= maxEntries) break;
+    const date = e.updatedAt ? ` (saved ${String(e.updatedAt).slice(0, 10)})` : '';
+    const cat = e.category && e.category !== RUN_NOTES_CATEGORY ? ` [${e.category}]` : '';
+    const line = redact(`- ${e.key}${cat}: ${oneLine(e.value)}${date}`, secrets);
+    if (lines.length > 0 && used + line.length + 1 > maxChars) break;
+    lines.push(line);
+    used += line.length + 1;
+  }
+  const hidden = ordered.length - lines.length;
+  if (hidden > 0) lines.push(`(${hidden} older note${hidden === 1 ? '' : 's'} not shown; agent_memory_list has them all.)`);
+  return [...header, ...lines].join('\n');
+}

package/src/utils/image-backbone.js

@@ -14,7 +14,7 @@
  * datasets/models never pulls the heavy runtime in.
  */
 import { readFileSync, existsSync } from 'fs';
-import { join, dirname, extname } from 'path';
+import { join, dirname, extname, basename } from 'path';
 import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
 
@@ -27,6 +27,16 @@ function requirePkg(name) {
 export const BACKBONE_ID = 'mobilenet-v3-small';
 export const INPUT_SIZE = 224;
 export const EMBED_DIM = 1024;
+/**
+ * Pictures up to this size are embedded exactly as lab-runtime embeds them
+ * (its MAX_MEGAPIXELS), so a shared model reads them the same way. Anything
+ * bigger, like a 48 MP phone photo, is box-shrunk to fit first: it keeps the
+ * float copy small and averages the detail the 224×224 resize would skip.
+ */
+const MAX_DIRECT_PIXELS = 16 * 1000 * 1000;
+/** jpeg-js's working memory cap; 512 MB stops short of 48 MP phone photos.
+ *  Its 100 MP resolution cap still applies. */
+const JPEG_MEMORY_MB = 2048;
 
 const BACKBONE_DIR = join(
   dirname(fileURLToPath(import.meta.url)),
@@ -99,18 +109,66 @@ function decodeImage(path) {
   if (!existsSync(path)) throw new Error(`Image not found: ${path}`);
   const buf = readFileSync(path);
   const ext = extname(path).toLowerCase();
-  if (ext === '.png') {
-    // Lazy require keeps these decoders out of the hot path for text/tabular.
-    const { PNG } = requirePkg('pngjs');
-    const png = PNG.sync.read(buf);
-    return { width: png.width, height: png.height, data: png.data };
+  if (ext !== '.png' && ext !== '.jpg' && ext !== '.jpeg') {
+    throw new Error(`Unsupported image type "${ext}". Use .jpg, .jpeg, or .png.`);
   }
-  if (ext === '.jpg' || ext === '.jpeg') {
+  try {
+    if (ext === '.png') {
+      // Lazy require keeps these decoders out of the hot path for text/tabular.
+      const { PNG } = requirePkg('pngjs');
+      const png = PNG.sync.read(buf);
+      return { width: png.width, height: png.height, data: png.data };
+    }
     const jpeg = requirePkg('jpeg-js');
-    const img = jpeg.decode(buf, { useTArray: true, maxMemoryUsageInMB: 512 });
+    const img = jpeg.decode(buf, { useTArray: true, maxMemoryUsageInMB: JPEG_MEMORY_MB });
     return { width: img.width, height: img.height, data: img.data };
+  } catch (e) {
+    const name = basename(path);
+    if (/maxResolutionInMP|maxMemoryUsageInMB/.test(e?.message || '')) {
+      throw new Error(`The picture "${name}" is too big to read. Make it smaller (under 100 megapixels) and add it again.`);
+    }
+    throw new Error(`The picture "${name}" couldn't be read. Try a different JPEG or PNG.`);
+  }
+}
+
+/**
+ * RGBA bytes → RGB floats in [0,1]. Pictures over MAX_DIRECT_PIXELS are
+ * averaged down by the smallest whole factor that fits (any leftover edge
+ * pixels are dropped); smaller ones are copied pixel for pixel.
+ */
+function toRgb({ width, height, data }) {
+  let k = 1;
+  while (Math.floor(width / k) * Math.floor(height / k) > MAX_DIRECT_PIXELS) k++;
+  const w = Math.floor(width / k);
+  const h = Math.floor(height / k);
+  const rgb = new Float32Array(w * h * 3);
+  if (k === 1) {
+    for (let i = 0, j = 0; i < data.length; i += 4, j += 3) {
+      rgb[j] = data[i] / 255;
+      rgb[j + 1] = data[i + 1] / 255;
+      rgb[j + 2] = data[i + 2] / 255;
+    }
+    return { rgb, w, h };
+  }
+  const scale = 1 / (k * k * 255);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      let r = 0, g = 0, b = 0;
+      for (let dy = 0; dy < k; dy++) {
+        let i = ((y * k + dy) * width + x * k) * 4;
+        for (let dx = 0; dx < k; dx++, i += 4) {
+          r += data[i];
+          g += data[i + 1];
+          b += data[i + 2];
+        }
+      }
+      const j = (y * w + x) * 3;
+      rgb[j] = r * scale;
+      rgb[j + 1] = g * scale;
+      rgb[j + 2] = b * scale;
+    }
   }
-  throw new Error(`Unsupported image type "${ext}". Use .jpg, .jpeg, or .png.`);
+  return { rgb, w, h };
 }
 
 /**
@@ -120,17 +178,11 @@ function decodeImage(path) {
 export async function embedImage(path) {
   const tf = await import('@tensorflow/tfjs');
   const model = await getBackbone();
-  const { width, height, data } = decodeImage(path);
+  const { rgb, w, h } = toRgb(decodeImage(path));
 
   return tf.tidy(() => {
-    // RGBA → RGB float [0,1], shaped [h, w, 3], resized to the backbone input.
-    const rgb = new Float32Array(width * height * 3);
-    for (let i = 0, j = 0; i < data.length; i += 4, j += 3) {
-      rgb[j] = data[i] / 255;
-      rgb[j + 1] = data[i + 1] / 255;
-      rgb[j + 2] = data[i + 2] / 255;
-    }
-    const img = tf.tensor3d(rgb, [height, width, 3]);
+    // RGB float [0,1], shaped [h, w, 3], resized to the backbone input.
+    const img = tf.tensor3d(rgb, [h, w, 3]);
     const resized = tf.image.resizeBilinear(img, [INPUT_SIZE, INPUT_SIZE]);
     const batched = resized.expandDims(0); // [1, 224, 224, 3]
     const out = model.predict(batched); // [1, 1024]