@myvillage/cli 2.15.0 → 2.16.0

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@myvillage/cli",
-  "version": "2.15.0",
+  "version": "2.16.0",
   "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');
+}