@myvillage/cli 1.83.0 → 1.85.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myvillage/cli",
-  "version": "1.83.0",
+  "version": "1.85.0",
   "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',

package/src/commands/agent-local.js

@@ -46,11 +46,13 @@ import {
   getLogFilePath,
 } from '../utils/local-agent.js';
 import { scaffoldAgent, TOOL_CATALOG, resolveCatalogEntry } from '../utils/agent-scaffolder.js';
+import { loadAgentRecipe, listAgentRecipes } from '../utils/agent-recipes.js';
 import { formatLocalAgentList, formatLocalAgentStatus } from '../utils/formatters.js';
+import { writeFileSync } from 'fs';
 
 // ── Create Local Agent (wizard) ─────────────────────────
 
-export async function agentCreateLocalCommand() {
+export async function agentCreateLocalCommand(options = {}) {
   if (!isAuthenticated()) {
     console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
     return;
@@ -118,7 +120,7 @@ export async function agentCreateLocalCommand() {
       {
         type: 'checkbox',
         name: 'tools',
-        message: 'Which built-in tools should your agent have? (you can add more later with `agent add-mcp`)',
+        message: 'Which built-in tools should your agent have? (you can add more later with `agent add-connector`)',
         choices: [
           { name: 'MyVillageOS MCP (feed, posts, communities, wallet)', value: 'myvillage', checked: true, disabled: 'always enabled' },
           { name: 'Local Files (read/write a sandboxed workspace)', value: 'filesystem', checked: true },
@@ -223,11 +225,28 @@ export async function agentCreateLocalCommand() {
       writeAgentConfig(answers.name, cfg);
     }
 
-    spinner.succeed('Agent scaffolded!');
+    // If --recipe was passed, fetch the Agent Recipe and materialize its
+    // prompt/tools/schedule over the freshly-scaffolded files. Best-effort:
+    // a fetch failure warns and leaves the blank agent in place — we never
+    // roll back the created agent.
+    let recipeApplied = null;
+    if (options.recipe) {
+      spinner.text = `Applying recipe "${options.recipe}"...`;
+      try {
+        recipeApplied = await applyAgentRecipe(answers.name, options.recipe);
+      } catch (err) {
+        recipeApplied = null;
+        // Downgrade spinner to a warning so the succeed() below still fires.
+        spinner.warn(`Recipe "${options.recipe}" not applied: ${err.message}`);
+        console.log(brand.teal('  Created a blank agent instead — customize it with `myvillage agent edit`.\n'));
+      }
+    }
+
+    spinner.succeed(recipeApplied ? `Agent scaffolded from recipe "${recipeApplied.name || options.recipe}"!` : 'Agent scaffolded!');
 
     console.log(brand.green(`  \u2713 Agent created at ~/.myvillage/agents/${answers.name}/\n`));
     console.log(brand.teal('  Next steps:'));
-    console.log(`    ${brand.gold(`myvillage agent add-mcp ${answers.name}`)}    Add a tool (GitHub, Twilio, your own MCP, etc.)`);
+    console.log(`    ${brand.gold(`myvillage agent add-connector ${answers.name}`)}    Add a tool (GitHub, Twilio, your own MCP, etc.)`);
     console.log(`    ${brand.gold(`myvillage agent grant ${answers.name} <provider>`)}  Authorize Google, Microsoft, or Slack`);
     console.log(`    ${brand.gold(`myvillage agent start ${answers.name}`)}     Launch the agent`);
     console.log(`    ${brand.gold(`myvillage agent edit ${answers.name}`)}      Customize the prompt`);
@@ -241,6 +260,77 @@ export async function agentCreateLocalCommand() {
   }
 }
 
+// ── Agent Recipes (starter templates) ───────────────────
+//
+// Fetch a server-side Agent Recipe and materialize it over the three local
+// files an agent already has: prompt.md (overwritten with recipe.promptMd),
+// tools.yaml (myvillage.allowed_tools set to recipe.myvillageTools), and
+// agent.config.yaml (schedule.check_in_interval / active_hours from
+// recipe.scheduleDefaults, if present). Returns the fetched recipe on success.
+// Throws on a fetch/404/network failure so the caller can warn and continue.
+
+async function applyAgentRecipe(agentName, slug) {
+  const recipe = await loadAgentRecipe(slug);
+
+  // 1. prompt.md — overwrite with the recipe's prompt.
+  if (typeof recipe.promptMd === 'string') {
+    writeFileSync(join(getAgentDir(agentName), 'prompt.md'), recipe.promptMd);
+  }
+
+  // 2. tools.yaml — set the myvillage server's allowed_tools list.
+  if (Array.isArray(recipe.myvillageTools)) {
+    const toolsConfig = readToolsYaml(agentName);
+    toolsConfig.servers = toolsConfig.servers || {};
+    toolsConfig.servers.myvillage = toolsConfig.servers.myvillage
+      || resolveCatalogEntry('myvillage', agentName);
+    toolsConfig.servers.myvillage.allowed_tools = [...recipe.myvillageTools];
+    writeToolsYaml(agentName, toolsConfig);
+  }
+
+  // 3. agent.config.yaml — apply schedule defaults if the recipe carries any.
+  const sched = recipe.scheduleDefaults;
+  if (sched && typeof sched === 'object') {
+    const cfg = readAgentConfig(agentName);
+    cfg.schedule = cfg.schedule || {};
+    if (sched.check_in_interval != null) {
+      cfg.schedule.check_in_interval = sched.check_in_interval;
+    }
+    if (sched.active_hours && typeof sched.active_hours === 'object') {
+      cfg.schedule.active_hours = { ...cfg.schedule.active_hours, ...sched.active_hours };
+    }
+    writeAgentConfig(agentName, cfg);
+  }
+
+  return recipe;
+}
+
+export async function agentRecipesListCommand() {
+  if (!isAuthenticated()) {
+    console.log(chalk.red("  ✗ Authentication required. Run 'myvillage login' first.\n"));
+    return;
+  }
+
+  let recipes;
+  try {
+    recipes = await listAgentRecipes();
+  } catch (err) {
+    console.log(chalk.red(`  ✗ ${err.message}\n`));
+    return;
+  }
+
+  if (!Array.isArray(recipes) || recipes.length === 0) {
+    console.log(brand.teal('  No agent recipes available yet.\n'));
+    return;
+  }
+
+  console.log(brand.teal('\n  Agent recipes (create with `myvillage agent create --recipe <slug>`):\n'));
+  for (const r of recipes) {
+    console.log(`  ${chalk.bold(r.slug)}  ${chalk.dim(r.name || '')}`);
+    if (r.description) console.log(`    ${chalk.dim(r.description)}`);
+  }
+  console.log('');
+}
+
 // ── Start Agent ─────────────────────────────────────────
 
 export async function agentStartCommand(name) {
@@ -762,7 +852,7 @@ export async function agentAddToolCommand(name, tool) {
   if (!validTools.includes(tool)) {
     console.log(chalk.red(`  \u2717 Unknown built-in tool "${tool}".`));
     console.log(brand.teal(`  Built-in tools: ${validTools.join(', ')}`));
-    console.log(brand.teal(`  For GitHub, Twilio, custom MCPs, etc. use: ${chalk.bold(`myvillage agent add-mcp ${name}`)}`));
+    console.log(brand.teal(`  For GitHub, Twilio, custom MCPs, etc. use: ${chalk.bold(`myvillage agent add-connector ${name}`)}`));
     console.log(brand.teal(`  For Google, Microsoft, or Slack use: ${chalk.bold(`myvillage agent grant ${name} <provider>`)}\n`));
     return;
   }

package/src/commands/agent-mcp.js

@@ -8,24 +8,24 @@ import {
   isDaemonRunning,
 } from '../utils/local-agent.js';
 import {
-  loadRecipe,
-  listRegistryRecipes,
-  recipeToServerEntry,
+  loadConnector,
+  listRegistryConnectors,
+  connectorToServerEntry,
   declaredEnvVars,
-} from '../utils/recipes.js';
+} from '../utils/connectors.js';
 import { isAuthenticated } from '../utils/auth.js';
 
-// ── add-mcp ─────────────────────────────────────────────
+// ── add-connector ───────────────────────────────────────
 //
 // Always interactive. If a source is provided (built-in name, local file,
-// or URL), the recipe's fields pre-fill the prompts but the developer can
+// or URL), the connector's fields pre-fill the prompts but the developer can
 // edit every value before it's written. If no source, the wizard collects
 // the fields from scratch.
 //
-// Use --yes to skip prompts and accept recipe values verbatim (useful for
+// Use --yes to skip prompts and accept connector values verbatim (useful for
 // scripts and CI).
 
-export async function agentAddMcpCommand(agentName, sourceArg, options = {}) {
+export async function agentAddConnectorCommand(agentName, sourceArg, options = {}) {
   if (!agentExists(agentName)) {
     console.log(chalk.red(`  ✗ Agent "${agentName}" not found. Run 'myvillage agent' to see your agents.\n`));
     return;
@@ -34,33 +34,33 @@ export async function agentAddMcpCommand(agentName, sourceArg, options = {}) {
   const source = sourceArg || options.from || null;
   const nonInteractive = options.yes === true;
 
-  let recipe = null;
+  let connector = null;
   if (source) {
     try {
-      recipe = await loadRecipe(source);
-      console.log(brand.teal(`  Loaded recipe: "${recipe.name}"${recipe.description ? ` — ${chalk.dim(recipe.description)}` : ''}\n`));
+      connector = await loadConnector(source);
+      console.log(brand.teal(`  Loaded connector: "${connector.name}"${connector.description ? ` — ${chalk.dim(connector.description)}` : ''}\n`));
     } catch (err) {
       console.log(chalk.red(`  ✗ ${err.message}\n`));
       return;
     }
   }
 
-  if (!recipe && nonInteractive) {
-    console.log(chalk.red('  ✗ --yes requires a recipe source (positional arg or --from). No source = interactive wizard.\n'));
+  if (!connector && nonInteractive) {
+    console.log(chalk.red('  ✗ --yes requires a connector source (positional arg or --from). No source = interactive wizard.\n'));
     return;
   }
 
-  // Walk through prompts. With a recipe, each prompt is pre-filled with the
-  // recipe's value. Without one, the developer fills in each field from
+  // Walk through prompts. With a connector, each prompt is pre-filled with the
+  // connector's value. Without one, the developer fills in each field from
   // scratch starting with the local-vs-remote choice.
   let finalized;
   try {
     finalized = nonInteractive
-      ? recipe
-      : await walkWizard(recipe);
+      ? connector
+      : await walkWizard(connector);
   } catch (err) {
     if (err.isTtyError) {
-      console.log(chalk.red('  ✗ Prompts cannot be rendered in this environment. Use --yes with a recipe source for scripted setup.\n'));
+      console.log(chalk.red('  ✗ Prompts cannot be rendered in this environment. Use --yes with a connector source for scripted setup.\n'));
       return;
     }
     console.log(chalk.red(`  ✗ ${err.message}\n`));
@@ -92,7 +92,7 @@ export async function agentAddMcpCommand(agentName, sourceArg, options = {}) {
     }
   }
 
-  toolsConfig.servers[finalized.name] = recipeToServerEntry(finalized);
+  toolsConfig.servers[finalized.name] = connectorToServerEntry(finalized);
   writeToolsYaml(agentName, toolsConfig);
 
   console.log(brand.green(`  ✓ Added "${finalized.name}" to agent "${agentName}".`));
@@ -120,9 +120,9 @@ export async function agentAddMcpCommand(agentName, sourceArg, options = {}) {
 
 // ── Wizard ──────────────────────────────────────────────
 
-async function walkWizard(recipe) {
-  // If no recipe, ask the developer what kind of MCP they're adding
-  if (!recipe) {
+async function walkWizard(connector) {
+  // If no connector, ask the developer what kind of MCP they're adding
+  if (!connector) {
     const { kind } = await inquirer.prompt([{
       type: 'list',
       name: 'kind',
@@ -132,12 +132,12 @@ async function walkWizard(recipe) {
         { name: 'Remote URL (e.g. https://mcp.example.com)', value: 'remote' },
       ],
     }]);
-    recipe = { name: '', description: '', env: {} };
-    if (kind === 'remote') recipe.url = '';
-    else recipe.command = 'npx';
+    connector = { name: '', description: '', env: {} };
+    if (kind === 'remote') connector.url = '';
+    else connector.command = 'npx';
   }
 
-  const isRemote = !!recipe.url;
+  const isRemote = !!connector.url;
 
   // Common fields
   const baseAnswers = await inquirer.prompt([
@@ -145,7 +145,7 @@ async function walkWizard(recipe) {
       type: 'input',
       name: 'name',
       message: 'Server name (key in tools.yaml):',
-      default: recipe.name || undefined,
+      default: connector.name || undefined,
       validate: v => /^[a-z0-9_-]+$/i.test((v || '').trim()) || 'lowercase letters, digits, dashes, underscores only',
       filter: v => v.trim(),
     },
@@ -153,19 +153,19 @@ async function walkWizard(recipe) {
       type: 'input',
       name: 'description',
       message: 'Description (optional, shown in tools.yaml):',
-      default: recipe.description || '',
+      default: connector.description || '',
       filter: v => v.trim(),
     },
   ]);
 
   if (isRemote) {
-    return await walkRemoteWizard(recipe, baseAnswers);
+    return await walkRemoteWizard(connector, baseAnswers);
   }
-  return await walkLocalWizard(recipe, baseAnswers);
+  return await walkLocalWizard(connector, baseAnswers);
 }
 
-async function walkLocalWizard(recipe, baseAnswers) {
-  const argsDefault = (recipe.args || []).join(' ');
+async function walkLocalWizard(connector, baseAnswers) {
+  const argsDefault = (connector.args || []).join(' ');
   const answers = await inquirer.prompt([
     {
       type: 'input',
@@ -186,7 +186,7 @@ async function walkLocalWizard(recipe, baseAnswers) {
       type: 'input',
       name: 'envNamesRaw',
       message: 'Env vars this MCP needs (comma-separated, leave blank for none):',
-      default: Object.keys(recipe.env || {}).join(', '),
+      default: Object.keys(connector.env || {}).join(', '),
       filter: v => v.trim(),
     },
   ]);
@@ -196,15 +196,15 @@ async function walkLocalWizard(recipe, baseAnswers) {
     ? answers.envNamesRaw.split(',').map(s => s.trim()).filter(Boolean)
     : [];
 
-  // Build env schema — preserve recipe-provided descriptions for known vars,
+  // Build env schema — preserve connector-provided descriptions for known vars,
   // mark new ones the developer added as required-by-default with no description.
   const env = {};
   for (const name of envNames) {
-    env[name] = recipe.env?.[name] || { description: '', required: true };
+    env[name] = connector.env?.[name] || { description: '', required: true };
   }
 
   return {
-    ...recipe,
+    ...connector,
     ...baseAnswers,
     command: answers.command,
     args,
@@ -212,8 +212,8 @@ async function walkLocalWizard(recipe, baseAnswers) {
   };
 }
 
-async function walkRemoteWizard(recipe, baseAnswers) {
-  const headerEntries = Object.entries(recipe.headers || {});
+async function walkRemoteWizard(connector, baseAnswers) {
+  const headerEntries = Object.entries(connector.headers || {});
   const defaultAuth = headerEntries.some(([k]) => /^authorization$/i.test(k)) ? 'bearer'
     : headerEntries.length > 0 ? 'custom' : 'none';
 
@@ -247,12 +247,12 @@ async function walkRemoteWizard(recipe, baseAnswers) {
       type: 'input',
       name: 'envVarName',
       message: 'Env var name that will hold the token:',
-      default: pickFirstEnvVarName(recipe) || 'MY_MCP_TOKEN',
+      default: pickFirstEnvVarName(connector) || 'MY_MCP_TOKEN',
       validate: v => /^[A-Z_][A-Z0-9_]*$/i.test(v) || 'must be a valid env-var name (letters, digits, underscores)',
       filter: v => v.trim(),
     }]);
     headers = { Authorization: `Bearer \${${envVarName}}` };
-    env = { [envVarName]: recipe.env?.[envVarName] || { description: 'Bearer token', required: true } };
+    env = { [envVarName]: connector.env?.[envVarName] || { description: 'Bearer token', required: true } };
   } else if (answers.authKind === 'custom') {
     const { headersRaw } = await inquirer.prompt([{
       type: 'input',
@@ -270,23 +270,23 @@ async function walkRemoteWizard(recipe, baseAnswers) {
       for (const m of matches) envNamesFromHeaders.add(m[1]);
     }
     for (const name of envNamesFromHeaders) {
-      env[name] = recipe.env?.[name] || { description: '', required: true };
+      env[name] = connector.env?.[name] || { description: '', required: true };
     }
   }
 
   return {
-    ...recipe,
+    ...connector,
     ...baseAnswers,
     url: answers.url,
-    transport: recipe.transport || 'http',
+    transport: connector.transport || 'http',
     headers,
     env,
   };
 }
 
-function pickFirstEnvVarName(recipe) {
-  if (!recipe.env || typeof recipe.env !== 'object') return null;
-  return Object.keys(recipe.env)[0] || null;
+function pickFirstEnvVarName(connector) {
+  if (!connector.env || typeof connector.env !== 'object') return null;
+  return Object.keys(connector.env)[0] || null;
 }
 
 function parseHeaderList(raw) {
@@ -324,34 +324,34 @@ export async function agentListMcpCommand(agentName) {
   console.log('');
 }
 
-// ── recipes ─────────────────────────────────────────────
+// ── connectors ──────────────────────────────────────────
 
-export async function recipesListCommand() {
+export async function connectorsListCommand() {
   if (!isAuthenticated()) {
     console.log(chalk.red("  ✗ Authentication required. Run 'myvillage login' first.\n"));
     return;
   }
 
-  let recipes;
+  let connectors;
   try {
-    recipes = await listRegistryRecipes();
+    connectors = await listRegistryConnectors();
   } catch (err) {
     console.log(chalk.red(`  ✗ ${err.message}\n`));
     return;
   }
 
-  if (recipes.length === 0) {
-    console.log(brand.teal('  The recipe registry is empty.\n'));
+  if (connectors.length === 0) {
+    console.log(brand.teal('  The connector registry is empty.\n'));
     return;
   }
 
-  console.log(brand.teal('\n  MyVillage curated MCP recipes (install with `agent add-mcp <agent> <name>`):\n'));
-  for (const r of recipes) {
-    const kind = r.kind === 'remote' ? 'remote' : 'local';
-    console.log(`  ${chalk.bold(r.name.padEnd(14))}${chalk.dim(`(${kind})`)} ${chalk.dim(r.description || '')}`);
-    if (r.envVars && r.envVars.length > 0) {
-      console.log(`  ${' '.repeat(14)}${chalk.dim('env: ' + r.envVars.join(', '))}`);
+  console.log(brand.teal('\n  MyVillage curated MCP connectors (install with `agent add-connector <agent> <name>`):\n'));
+  for (const c of connectors) {
+    const kind = c.kind === 'remote' ? 'remote' : 'local';
+    console.log(`  ${chalk.bold(c.name.padEnd(14))}${chalk.dim(`(${kind})`)} ${chalk.dim(c.description || '')}`);
+    if (c.envVars && c.envVars.length > 0) {
+      console.log(`  ${' '.repeat(14)}${chalk.dim('env: ' + c.envVars.join(', '))}`);
     }
   }
-  console.log(brand.teal('\n  External recipes: install with `--from <path-or-url>`.\n'));
+  console.log(brand.teal('\n  External connectors: install with `--from <path-or-url>`.\n'));
 }

package/src/commands/agent.js

@@ -66,13 +66,19 @@ export async function agentCommand(handle) {
   }
 }
 
-export async function agentCreateCommand() {
+export async function agentCreateCommand(options = {}) {
   if (!isAuthenticated()) {
     console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
     return;
   }
 
   try {
+    // A --recipe implies a local agent (recipes materialize prompt.md / tools.yaml
+    // / agent.config.yaml, which only local agents have) \u2014 skip the gate question.
+    if (options.recipe) {
+      return agentCreateLocalCommand(options);
+    }
+
     // Gate question: local or external?
     const { agentType } = await inquirer.prompt([{
       type: 'list',
@@ -85,7 +91,7 @@ export async function agentCreateCommand() {
     }]);
 
     if (agentType === 'local') {
-      return agentCreateLocalCommand();
+      return agentCreateLocalCommand(options);
     }
 
     // Fetch the caller's existing agents to offer as parent choices for the