clementine-agent 1.18.51 → 1.18.53

package/dist/agent/mcp-bridge.d.ts

@@ -41,18 +41,18 @@ export interface ClaudeIntegration {
     connected: boolean;
 }
 /**
- * Check if a tool name is a Claude Desktop integration tool.
+ * Check if a tool name is a claude.ai integration tool.
  * Format: mcp__claude_ai_<IntegrationName>__<tool_name>
  */
 export declare function isClaudeDesktopTool(toolName: string): boolean;
 /** Load persisted integrations from disk. */
 export declare function loadClaudeIntegrations(): Record<string, ClaudeIntegration>;
 /**
- * Record a Claude Desktop integration tool use.
+ * Record a claude.ai integration tool use.
  * Call this whenever a mcp__claude_ai_* tool is seen in a tool_use block.
  */
 export declare function recordClaudeIntegrationUse(toolName: string): void;
-/** Get all discovered Claude Desktop integrations as a list. */
+/** Get all discovered claude.ai integrations as a list. */
 export declare function getClaudeIntegrations(): ClaudeIntegration[];
 export interface ToolInventory {
     /** ISO timestamp of the probe */
@@ -66,17 +66,18 @@ export declare function loadToolInventory(): ToolInventory | null;
  * returns every tool Claude Code is actually surfacing — claude_ai_*
  * connectors, plugins, built-ins, custom MCP servers. Cached for 24h.
  * This removes any need to hardcode user-specific tool names in the
- * system prompt; whatever Claude Desktop is currently connecting to the
- * user's account becomes automatically available to the agent.
+ * system prompt; whatever the SDK currently surfaces (claude.ai
+ * connectors, Composio toolkits, local stdio MCP servers) becomes
+ * automatically available to the agent.
  */
 export declare function probeAvailableTools(force?: boolean): Promise<ToolInventory>;
 /**
  * Register every integration found in a tool inventory. The SDK's system
  * init message (subtype='init') includes a `tools: string[]` with the full
  * set of tools the agent actually has access to this session — including
- * every mcp__claude_ai_* tool Claude Desktop is surfacing. Walking that
- * list on init gives us the authoritative, up-to-date integration set
- * without waiting for the agent to blindly try each one.
+ * every mcp__claude_ai_* tool the SDK is surfacing from claude.ai
+ * connectors. Walking that list on init gives us the authoritative,
+ * up-to-date integration set without waiting for the agent to blindly try each one.
  *
  * Idempotent: if an entry already exists, we merge new tool names into it
  * and bump `connected = true` without touching firstSeen/lastUsed.

package/dist/agent/mcp-bridge.js

@@ -318,7 +318,7 @@ const INTEGRATION_LABELS = {
     'Salesforce': 'Salesforce',
 };
 /**
- * Check if a tool name is a Claude Desktop integration tool.
+ * Check if a tool name is a claude.ai integration tool.
  * Format: mcp__claude_ai_<IntegrationName>__<tool_name>
  */
 export function isClaudeDesktopTool(toolName) {
@@ -351,7 +351,7 @@ function saveClaudeIntegrations(integrations) {
     writeFileSync(INTEGRATIONS_FILE, JSON.stringify(integrations, null, 2));
 }
 /**
- * Record a Claude Desktop integration tool use.
+ * Record a claude.ai integration tool use.
  * Call this whenever a mcp__claude_ai_* tool is seen in a tool_use block.
  */
 export function recordClaudeIntegrationUse(toolName) {
@@ -380,7 +380,7 @@ export function recordClaudeIntegrationUse(toolName) {
     }
     saveClaudeIntegrations(integrations);
 }
-/** Get all discovered Claude Desktop integrations as a list. */
+/** Get all discovered claude.ai integrations as a list. */
 export function getClaudeIntegrations() {
     return Object.values(loadClaudeIntegrations());
 }
@@ -414,8 +414,9 @@ function saveToolInventory(inv) {
  * returns every tool Claude Code is actually surfacing — claude_ai_*
  * connectors, plugins, built-ins, custom MCP servers. Cached for 24h.
  * This removes any need to hardcode user-specific tool names in the
- * system prompt; whatever Claude Desktop is currently connecting to the
- * user's account becomes automatically available to the agent.
+ * system prompt; whatever the SDK currently surfaces (claude.ai
+ * connectors, Composio toolkits, local stdio MCP servers) becomes
+ * automatically available to the agent.
  */
 export async function probeAvailableTools(force = false) {
     const cached = loadToolInventory();
@@ -487,9 +488,9 @@ export async function probeAvailableTools(force = false) {
  * Register every integration found in a tool inventory. The SDK's system
  * init message (subtype='init') includes a `tools: string[]` with the full
  * set of tools the agent actually has access to this session — including
- * every mcp__claude_ai_* tool Claude Desktop is surfacing. Walking that
- * list on init gives us the authoritative, up-to-date integration set
- * without waiting for the agent to blindly try each one.
+ * every mcp__claude_ai_* tool the SDK is surfacing from claude.ai
+ * connectors. Walking that list on init gives us the authoritative,
+ * up-to-date integration set without waiting for the agent to blindly try each one.
  *
  * Idempotent: if an entry already exists, we merge new tool names into it
  * and bump `connected = true` without touching firstSeen/lastUsed.
@@ -583,7 +584,7 @@ export function bootstrapClaudeIntegrationsFromAuditLog(auditLogPath) {
         }
         if (changed) {
             saveClaudeIntegrations(integrations);
-            logger.info({ count: Object.keys(integrations).length }, 'Bootstrapped Claude Desktop integrations from audit log');
+            logger.info({ count: Object.keys(integrations).length }, 'Bootstrapped claude.ai integrations from audit log');
         }
     }
     catch (err) {

package/dist/agent/run-agent-context.d.ts

@@ -14,4 +14,14 @@ export interface BuildChatContextOptions {
  * SDK then runs with just the bare `claude_code` preset.
  */
 export declare function buildChatSystemAppend(opts?: BuildChatContextOptions): string;
+/**
+ * Read the long-term memory block for an autonomous run (cron, team-task).
+ * Returns the agent-specific MEMORY.md when a hired agent is active, the
+ * global MEMORY.md when running as Clementine, or empty when neither
+ * exists. Returns a heading-prefixed block ready to drop into a prompt.
+ *
+ * Heartbeats deliberately skip this — they're tool-free Haiku decisions
+ * and a 6KB memory block defeats the cost economy.
+ */
+export declare function buildAutonomousMemoryContext(profile?: AgentProfile | null): string;
 //# sourceMappingURL=run-agent-context.d.ts.map

package/dist/agent/run-agent-context.js

@@ -41,40 +41,70 @@ function trimTo(text, max) {
  */
 export function buildChatSystemAppend(opts = {}) {
     const blocks = [];
-    // 1. Soul (personality + voice)
-    const soul = readFileSafe(SOUL_FILE);
-    if (soul.trim()) {
-        blocks.push(`## Identity & Voice\n${trimTo(soul, SOUL_MAX_CHARS)}`);
+    const isHiredAgent = !!opts.profile && opts.profile.slug !== 'clementine';
+    // 1. Identity & Voice.
+    //    - Clementine main agent: SOUL.md (the global personality file).
+    //    - Hired agent main: their own profile.systemPromptBody IS their
+    //      identity — don't load Clementine's SOUL on top of it.
+    if (!isHiredAgent) {
+        const soul = readFileSafe(SOUL_FILE);
+        if (soul.trim()) {
+            blocks.push(`## Identity & Voice\n${trimTo(soul, SOUL_MAX_CHARS)}`);
+        }
     }
-    // 2. Long-term memory — agent-specific file overrides the global one.
-    const profileMemoryPath = opts.profile?.slug
+    // 2. Long-term memory — agent-specific file when a hired agent is
+    //    active, otherwise the global one.
+    const profileMemoryPath = isHiredAgent
         ? path.join(AGENTS_DIR, opts.profile.slug, 'MEMORY.md')
         : null;
-    let memory = '';
     if (profileMemoryPath && fs.existsSync(profileMemoryPath)) {
-        memory = readFileSafe(profileMemoryPath);
+        const memory = readFileSafe(profileMemoryPath);
         if (memory.trim()) {
-            blocks.push(`## Long-Term Memory (${opts.profile?.name ?? opts.profile?.slug})\n${trimTo(memory, PROFILE_MEMORY_MAX_CHARS)}`);
+            blocks.push(`## Long-Term Memory (${opts.profile.name ?? opts.profile.slug})\n${trimTo(memory, PROFILE_MEMORY_MAX_CHARS)}`);
         }
     }
     else {
-        memory = readFileSafe(MEMORY_FILE);
+        const memory = readFileSafe(MEMORY_FILE);
         if (memory.trim()) {
             blocks.push(`## Long-Term Memory\n${trimTo(memory, MEMORY_MAX_CHARS)}`);
         }
     }
     // 3. Team roster (only when not running AS a hired agent — Sasha
     //    doesn't need to be told who Sasha is).
-    if (!opts.profile) {
+    if (!isHiredAgent) {
         const agentsRoster = readFileSafe(AGENTS_FILE);
         if (agentsRoster.trim()) {
             blocks.push(`## Team Roster\n${trimTo(agentsRoster, AGENTS_MAX_CHARS)}`);
         }
     }
-    // 4. Profile system prompt body (e.g. Sasha's role description).
+    // 4. Profile system prompt body (the hired agent's identity + role).
     if (opts.profileAppend?.trim()) {
         blocks.push(opts.profileAppend);
     }
     return blocks.join('\n\n');
 }
+/**
+ * Read the long-term memory block for an autonomous run (cron, team-task).
+ * Returns the agent-specific MEMORY.md when a hired agent is active, the
+ * global MEMORY.md when running as Clementine, or empty when neither
+ * exists. Returns a heading-prefixed block ready to drop into a prompt.
+ *
+ * Heartbeats deliberately skip this — they're tool-free Haiku decisions
+ * and a 6KB memory block defeats the cost economy.
+ */
+export function buildAutonomousMemoryContext(profile) {
+    const isHiredAgent = !!profile && profile.slug !== 'clementine';
+    const memoryPath = isHiredAgent
+        ? path.join(AGENTS_DIR, profile.slug, 'MEMORY.md')
+        : MEMORY_FILE;
+    if (!fs.existsSync(memoryPath))
+        return '';
+    const memory = readFileSafe(memoryPath);
+    if (!memory.trim())
+        return '';
+    const label = isHiredAgent
+        ? `Long-Term Memory (${profile.name ?? profile.slug})`
+        : 'Long-Term Memory';
+    return `## ${label}\n${trimTo(memory, isHiredAgent ? PROFILE_MEMORY_MAX_CHARS : MEMORY_MAX_CHARS)}\n\n`;
+}
 //# sourceMappingURL=run-agent-context.js.map

package/dist/agent/run-agent-cron.js

@@ -20,6 +20,7 @@ import pino from 'pino';
 import { BASE_DIR, VAULT_DIR, CRON_PROGRESS_DIR, } from '../config.js';
 import { runAgent } from './run-agent.js';
 import { buildExtraMcpForRunAgent } from './run-agent-mcp.js';
+import { buildAutonomousMemoryContext } from './run-agent-context.js';
 import { listAllGoals } from '../tools/shared.js';
 const CRON_PROGRESS_PENDING_MAX_ITEMS = 20;
 const CRON_PROGRESS_NOTES_MAX_CHARS = 2000;
@@ -234,6 +235,10 @@ export async function runAgentCron(opts) {
     const agentSlug = opts.profile?.slug;
     const ownerName = process.env.OWNER_NAME ?? 'the user';
     // ── Compose context blocks (mirrors legacy runCronJob) ─────────────
+    // Memory block goes first so the agent reads its long-term context
+    // before the run-specific progress/goals/etc. For a hired agent
+    // (Ross/Sasha) this is their own MEMORY.md, not Clementine's global.
+    const memoryContext = buildAutonomousMemoryContext(opts.profile);
     const progressContext = buildProgressContext(opts.jobName);
     const goalContext = buildGoalContext(opts.jobName);
     const delegationContext = buildDelegationContext(agentSlug);
@@ -246,6 +251,7 @@ export async function runAgentCron(opts) {
     // spawns isolated sub-agents without a hand-rolled prompt directive.
     // Final prompt
     const builtPrompt = `[Scheduled task: ${opts.jobName}]\n\n` +
+        memoryContext +
         progressContext +
         goalContext +
         skillContext +

package/dist/agent/run-agent-team-task.js

@@ -17,15 +17,21 @@
 import pino from 'pino';
 import { runAgent } from './run-agent.js';
 import { buildExtraMcpForRunAgent } from './run-agent-mcp.js';
+import { buildAutonomousMemoryContext } from './run-agent-context.js';
 const logger = pino({ name: 'clementine.run-agent-team-task' });
 export async function runAgentTeamTask(opts) {
     const taskName = `team-msg:${opts.fromSlug}-to-${opts.profile.slug}`;
     const now = new Date();
     const timestamp = now.toISOString().slice(0, 16).replace('T', ' ');
+    // Inject the recipient's own long-term memory so they have context
+    // about prior work, preferences, and team relationships before
+    // processing the message.
+    const memoryContext = buildAutonomousMemoryContext(opts.profile);
     // Match the legacy phase-1 prompt shape so existing agent training
     // (Sasha/Ross/Nora) keeps responding the same way. Phases 2+ are no
     // longer needed — the SDK keeps the conversation in one session.
     const builtPrompt = `[TEAM MESSAGE from ${opts.fromName} (${opts.fromSlug}) — ${timestamp}]\n\n` +
+        memoryContext +
         `You received a direct message from a teammate. Process it fully and autonomously.\n\n` +
         `MESSAGE:\n${opts.content}\n\n` +
         `IMPORTANT:\n` +

package/dist/index.js

@@ -571,14 +571,22 @@ async function asyncMain() {
         // refresh_tool_inventory after intentionally adding connectors.
         const inv = loadToolInventory();
         if (inv) {
-            const integrations = new Set();
+            const claudeAiIntegrations = new Set();
+            let claudeAiToolCount = 0;
             for (const t of inv.tools) {
                 const m = t.match(/^mcp__claude_ai_([^_]+(?:_[^_]+)*)__/);
-                if (m)
-                    integrations.add(m[1].replace(/_/g, ' '));
+                if (m) {
+                    claudeAiIntegrations.add(m[1].replace(/_/g, ' '));
+                    claudeAiToolCount++;
+                }
             }
-            if (integrations.size > 0) {
-                logger.info({ integrations: [...integrations].sort(), toolCount: inv.tools.length, probedAt: inv.probedAt }, '🦞 Cached Claude Desktop integrations loaded');
+            if (claudeAiIntegrations.size > 0) {
+                logger.info({
+                    claudeAiIntegrations: [...claudeAiIntegrations].sort(),
+                    claudeAiToolCount,
+                    totalToolInventory: inv.tools.length,
+                    probedAt: inv.probedAt,
+                }, '🦞 Cached claude.ai integrations loaded');
             }
             // After inventory is live, fetch canonical schemas from every stdio
             // MCP server we can reach, then synthesize auto-skills for every

package/dist/tools/admin-tools.js

@@ -325,7 +325,7 @@ export function registerAdminTools(server) {
         const unique = [...new Set(tools)].sort();
         writeFileSync(ALLOWED_TOOLS_EXTRA, JSON.stringify(unique, null, 2));
     }
-    server.tool('allow_tool', 'Add a tool name to your self-managed allowedTools list. Use when you see a tool in the SDK inventory but get "not in function schema" when you try to call it. Writes to ~/.clementine/allowed-tools-extra.json; takes effect on your NEXT query. If the tool name isn\'t yet in the cached inventory, this auto-refreshes the probe first — covers the case where the owner just added a new Claude Desktop connector. Owner-DM only.', {
+    server.tool('allow_tool', 'Add a tool name to your self-managed allowedTools list. Use when you see a tool in the SDK inventory but get "not in function schema" when you try to call it. Writes to ~/.clementine/allowed-tools-extra.json; takes effect on your NEXT query. If the tool name isn\'t yet in the cached inventory, this auto-refreshes the probe first — covers the case where the owner just added a new claude.ai connector or local MCP server. Owner-DM only.', {
         name: z.string().describe('Exact tool name (e.g. "mcp__claude_ai_Google_Drive__search_files")'),
         reason: z.string().optional().describe('Brief note: why you need this tool. For audit trail.'),
     }, async ({ name, reason }) => {
@@ -368,7 +368,7 @@ export function registerAdminTools(server) {
         logger.info({ name: trimmed, reason, totalExtras: current.length }, 'allow_tool');
         return textResult(`Added ${trimmed} to ~/.clementine/allowed-tools-extra.json (${current.length} total extras)${refreshNote}. Active on your next query — no daemon restart needed.${reason ? ` Reason: ${reason}` : ''}`);
     });
-    server.tool('refresh_tool_inventory', 'Force a fresh probe of the SDK\'s tool inventory, picking up any Claude Desktop connectors the owner has added since the last cache refresh. Owner-DM only. Use this when the owner says "I just added X at claude.ai" or when an expected integration isn\'t showing up. Updates ~/.clementine/.tool-inventory.json and syncs claude-integrations.json. Returns a diff of what changed.', {}, async () => {
+    server.tool('refresh_tool_inventory', 'Force a fresh probe of the SDK\'s tool inventory, picking up any claude.ai connectors, Composio toolkits, or local MCP servers the owner has added since the last cache refresh. Owner-DM only. Use this when the owner says "I just added X at claude.ai" or when an expected integration isn\'t showing up. Updates ~/.clementine/.tool-inventory.json and syncs claude-integrations.json. Returns a diff of what changed.', {}, async () => {
         const gate = requireOwnerDm();
         if (!gate.ok)
             return textResult(gate.message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.18.51",
+  "version": "1.18.53",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",