@myvillage/cli 1.84.0 → 1.85.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myvillage/cli",
-  "version": "1.84.0",
+  "version": "1.85.2",
   "description": "MyVillageOS CLI for community developers",
   "type": "module",
   "bin": {

package/src/agent-runtime/context.js

@@ -1,103 +1,25 @@
 // ── Context Gathering ───────────────────────────────────
 // Assembles a context snapshot for each agent loop iteration.
 // This becomes the user message sent to the LLM.
+//
+// NOTE: This intentionally does NOT auto-fetch the community feed, network
+// events, or mentions. Pushing that data into every loop of every agent was
+// wasteful — most iterations don't act on it, yet each one cost three
+// uncached HTTP round-trips (feed + events + mentions) plus the tokens to
+// render them. Community activity is now pull-on-demand: an agent whose job
+// involves the network requests it through its MCP tools (network_feed,
+// network_search, network_post_get, network_comment_list, …). The instruction
+// block below tells the agent how and when to go look.
 
-import { getAgentFeed, getAgentMentions, getAgentEvents } from '../utils/api.js';
 import { listDatasets } from '../utils/dataset-workspace.js';
 import { listModels } from '../utils/model-workspace.js';
 
 export async function gatherContext(agentConfig, lastCheckIn, recentActions = []) {
   const parts = [];
-  let mentionsCount = 0;
-  let eventsCount = 0;
 
   parts.push(`Current time: ${new Date().toISOString()}`);
   parts.push(`Last check-in: ${lastCheckIn || 'never'}`);
 
-  const agentId = agentConfig.man?.agent_id;
-
-  // Fetch new feed activity since last check-in. The agent-scoped feed
-  // endpoint is enforced server-side: posts from public communities OR
-  // communities this agent is a member of. Caller cannot widen the scope.
-  if (agentId) {
-    try {
-      const params = { pageSize: 30 };
-      if (lastCheckIn) {
-        params.since = lastCheckIn;
-      }
-      const result = await getAgentFeed(agentId, params);
-      const items = result.data || result;
-
-      if (Array.isArray(items) && items.length > 0) {
-        parts.push(`\nNew feed activity (${items.length} items):`);
-        for (const item of items.slice(0, 20)) {
-          const author = item.agentProfile?.handle
-            || item.villager?.firstName
-            || 'unknown';
-          const community = item.community?.slug || '?';
-          const preview = (item.body || item.title || '').slice(0, 120);
-          parts.push(`- @${author} in r/${community}: ${preview}`);
-        }
-        if (items.length > 20) {
-          parts.push(`... and ${items.length - 20} more items`);
-        }
-      } else {
-        parts.push('\nNo new feed activity since last check-in.');
-      }
-    } catch {
-      parts.push('\nCould not fetch feed (network error).');
-    }
-
-    // Fetch network events (NEW_POST, NEW_MEMBER, etc.) the agent has visibility for.
-    try {
-      const eventParams = { pageSize: 20 };
-      if (lastCheckIn) eventParams.since = lastCheckIn;
-      const eventResult = await getAgentEvents(agentId, eventParams);
-      const events = eventResult.data || eventResult;
-
-      if (Array.isArray(events) && events.length > 0) {
-        eventsCount = events.length;
-        parts.push(`\nNetwork events since last check-in (${events.length}):`);
-        for (const e of events.slice(0, 10)) {
-          parts.push(`- [${e.eventType}] source=${e.sourceEntityType}:${e.sourceEntityId}`);
-        }
-        if (events.length > 10) {
-          parts.push(`... and ${events.length - 10} more events`);
-        }
-      }
-    } catch {
-      // Events fetch failed — not critical, skip silently
-    }
-
-    // Fetch mentions since last check-in
-    try {
-      const mentionParams = { pageSize: 20 };
-      if (lastCheckIn) mentionParams.since = lastCheckIn;
-      const mentionResult = await getAgentMentions(agentId, mentionParams);
-      const mentions = mentionResult.data || mentionResult;
-
-      if (Array.isArray(mentions) && mentions.length > 0) {
-        mentionsCount = mentions.length;
-        parts.push(`\nMentions since last check-in (${mentions.length}):`);
-        for (const m of mentions.slice(0, 10)) {
-          const author = m.agentProfile?.handle
-            || m.villager?.firstName
-            || 'unknown';
-          const preview = (m.body || m.title || '').slice(0, 120);
-          const type = m.postId ? 'comment' : 'post';
-          parts.push(`- [${type}] @${author}: ${preview}`);
-        }
-        if (mentions.length > 10) {
-          parts.push(`... and ${mentions.length - 10} more mentions`);
-        }
-      }
-    } catch {
-      // Mentions fetch failed — not critical, skip silently
-    }
-  } else {
-    parts.push('\nNot registered on MAN feed yet.');
-  }
-
   // Include recent actions so the agent knows what it already did
   if (recentActions.length > 0) {
     parts.push('\nYour recent actions:');
@@ -139,15 +61,19 @@ export async function gatherContext(agentConfig, lastCheckIn, recentActions = []
     /* no local models / store unavailable — skip */
   }
 
-  parts.push('\nDecide what actions to take based on your personality and the current context.');
+  // Behavioral instructions.
+  //
+  // Community activity (feed / events / mentions) is deliberately NOT included
+  // above — it is pulled on demand instead. If engaging with the network is
+  // part of this agent's purpose, it must go look for itself using whatever
+  // community tools it has been granted.
+  parts.push('\nDecide what to do this iteration based on your purpose, your personality, and any active task.');
+  parts.push('Community activity (posts, comments, mentions) is NOT included above — nothing is pushed to you automatically. If engaging with the community is part of your job, use your tools to look: e.g. network_feed for recent activity, network_search to find specific posts or mentions of you, and network_post_get / network_comment_list to read a thread before replying. (Only relevant if those tools are available to you.)');
+  parts.push('Fetch only what you actually need this iteration, and only if your purpose calls for it — do not pull the feed just because you can.');
   parts.push('IMPORTANT: If you already commented on a post, only comment again if someone ELSE has replied since your last comment. Do not leave multiple unanswered comments on the same post.');
-  parts.push('If there is no new activity and no one has responded to your previous comments, do nothing — that is a valid choice.');
-  parts.push('You may post, comment, vote, read files, or do nothing if appropriate.');
+  parts.push('Doing nothing is a valid choice — if nothing needs your attention right now, take no action.');
+  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'),
-    mentionsCount,
-    eventsCount,
-  };
+  return { text: parts.join('\n') };
 }

package/src/agent-runtime/loop.js

@@ -257,11 +257,13 @@ export async function agentLoop(agentName, { signal }) {
         activeTask = await pollAndClaim(config.man.village_agent_id, agentDir);
       }
 
-      // Gather context (returns { text, mentionsCount, eventsCount })
+      // Gather context (returns { text }). Community feed/events/mentions are
+      // 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);
       let context = contextResult.text;
-      mentionsFound = contextResult.mentionsCount;
-      const eventsFound = contextResult.eventsCount || 0;
+      const eventsFound = 0;
 
       if (activeTask) {
         // A claimed task takes over the iteration. The default monitoring
@@ -279,16 +281,16 @@ Guidelines:
 - Use as many tool calls as needed to complete the task. A single discovery call (e.g. listing directories) is usually NOT enough — follow up with the calls that actually produce the requested result.
 - Do not stop after one tool call unless that call alone fulfills the entire instruction.
 - Do not ask clarifying questions back to the user; make a reasonable interpretation and proceed.
-- The feed context is provided only for situational awareness — do not let "no new feed activity" prevent you from carrying out the task.
+- The ambient context below is provided only for situational awareness — carry out the task regardless of what it contains.
 - Your final text response should include the actual answer/output the user asked for (e.g. the list of files, the summary, the result), not just a description of what you did.`;
 
-        context = `## TASK (id=${activeTask.id}, type=${activeTask.taskType})\n${instructionText}\n\n---\n\n## FEED CONTEXT (for awareness only)\n${context}`;
+        context = `## TASK (id=${activeTask.id}, type=${activeTask.taskType})\n${instructionText}\n\n---\n\n## AMBIENT CONTEXT (for awareness only)\n${context}`;
 
         logActivity(agentDir, { type: 'task_claimed', taskId: activeTask.id, taskType: activeTask.taskType });
       }
 
-      // Count feed items from context
-      feedItemsRead = (context.match(/^- @/gm) || []).length;
+      // Feed is no longer pushed into context; nothing to count here.
+      // feedItemsRead / mentionsFound stay 0 (see declarations above).
 
       logActivity(agentDir, {
         type: 'context',
@@ -633,6 +635,25 @@ const ACTION_TOOLS = new Set([
   'task_assign',
   'task_complete',
   'task_retry',
+  // Curriculum actions — creating/assigning activities and projects is real,
+  // externally-visible work. Without these, a curriculum-generator agent that
+  // successfully creates and assigns activities scores zero successful action
+  // tools, so any incidental flagged result marks the whole task FAILED.
+  'activity_create',
+  'activity_assign',
+  'activity_update',
+  'activity_delete',
+  'project_create',
+  'project_update',
+  'project_delete',
+]);
+
+// Read-only lookups whose "not found" result is an expected empty read, not a
+// failure. A missing agent_memory_get key is normal the first time an agent
+// touches a villager and must not be treated as a task-failing tool error.
+const BENIGN_NOT_FOUND_TOOLS = new Set([
+  'agent_memory_get',
+  'agent_memory_list',
 ]);
 
 function flattenToolResultText(tr) {
@@ -664,6 +685,14 @@ function isToolResultError(tr) {
   // "the user was unauthorized to do X" because we anchor on word boundaries.
   const text = flattenToolResultText(tr);
   if (!text) return false;
+  // A memory/lookup read that misses is an expected empty result, not an
+  // error. agent_memory_get returns "Memory key ... not found" the first time
+  // an agent touches a villager; flagging that would fail the whole task even
+  // though nothing went wrong. Real transport errors on these tools still set
+  // the explicit isError flag handled above, so they are unaffected.
+  if (BENIGN_NOT_FOUND_TOOLS.has(tr.toolName) && /\bnot found\b/i.test(text)) {
+    return false;
+  }
   return /\b(40[0-9]|50[0-9])\b/.test(text) ||
     /\b(not found|unauthorized|forbidden|invalid|insufficient_quota|authentication failed)\b/i.test(text);
 }

package/src/utils/api.js

@@ -689,11 +689,24 @@ export async function claimAgentTask(villageAgentId, taskId) {
 // otherwise the task is marked COMPLETED with the given `output`.
 export async function completeAgentTask(villageAgentId, taskId, data = {}) {
   const client = getPlatformClient();
-  const response = await client.post(
-    `/village-agents/${encodeURIComponent(villageAgentId)}/tasks/${encodeURIComponent(taskId)}/complete`,
-    data,
-  );
-  return response.data;
+  try {
+    const response = await client.post(
+      `/village-agents/${encodeURIComponent(villageAgentId)}/tasks/${encodeURIComponent(taskId)}/complete`,
+      data,
+    );
+    return response.data;
+  } catch (err) {
+    // Idempotent completion. The task may already be terminal because the agent
+    // completed it itself via the `agent_task_complete` tool during its run (the
+    // daemon also completes the active task at the end of each iteration), or a
+    // retry raced. A 409 "already terminal" means the task reached the end state
+    // we wanted — treat it as success rather than a failure so the daemon doesn't
+    // log a spurious "Failed to mark task complete" error every run.
+    if (err?.response?.status === 409) {
+      return { alreadyTerminal: true, message: err.response?.data?.error };
+    }
+    throw err;
+  }
 }
 
 // Retry a single FAILED or CANCELLED task: resets it to PENDING so the