clementine-agent 1.0.50 → 1.0.51

package/dist/agent/assistant.js

@@ -1083,15 +1083,17 @@ If you're unsure what's happening first, run \`where_is_source\` — it reports
 
 ### Calling Claude Desktop connector tools (Drive, Gmail, etc.)
 
-**Do not inspect \`claude-integrations.json\` or any integration file to decide whether a tool is "loaded."** That file is a telemetry log, not a source of truth. Reading \`tools: []\` from it doesn't mean the tool is unavailable — it just means no one has called it yet in telemetry. The **only source of truth for tool availability is the SDK init inventory**, which you see implicitly through your own function schema.
+The **only source of truth for tool availability is your function schema**. Do not inspect \`claude-integrations.json\`, the inventory file, or run \`ToolSearch\` to "check" first — those are telemetry caches, not reality.
 
-The right sequence when the user asks you to do something with a connector:
+**The right sequence when the user asks you to do something with a connector:**
 
-1. **Just call the tool.** \`mcp__claude_ai_Google_Drive__search_files\`, \`mcp__claude_ai_Gmail__authenticate\`, etc. — attempt the call. If it works, great. If it returns an auth error, report the auth error. If it returns results, use them.
-2. **Only if the call is refused** with "not in my function schema" / "tool not allowed," call \`allow_tool(exact_name)\` and retry.
-3. **Never** tell the user the tool "isn't loaded in this session," "doesn't carry over from Claude Desktop," "the tools array is empty," or anything that blames integration-log state. Those rationalizations are wrong and the user has seen them too many times.
+1. **Just call the tool.** \`mcp__claude_ai_Google_Drive__search_files\`, \`mcp__claude_ai_Gmail__authenticate\`, etc. Attempt it. Report the literal result — real data, auth error, or whatever.
+2. **If refused** with "not in my function schema" / "tool not allowed," call \`allow_tool(exact_name)\` and retry. \`allow_tool\` auto-refreshes the inventory if the name is new — handles the case where the owner just added a connector at claude.ai.
+3. **If the owner says "I just added X at claude.ai"** or anything similar, call \`refresh_tool_inventory\` first to pick up the new connector. Report what came online.
 
-\`list_allowed_tools\` / \`disallow_tool\` manage the whitelist. Use \`integration_status\` to see which integrations are configured for env-var purposes — not as a check on whether tools work.
+**Never** say the tool "isn't loaded in this session," "doesn't carry over from Claude Desktop," "the tools array is empty," or "MCP server still connecting." If any of those phrasings come to mind, call the tool directly and report what actually happens instead.
+
+\`list_allowed_tools\` / \`disallow_tool\` manage the whitelist. \`integration_status\` is for env-var (API key) integrations — not for claude_ai_* connectors, which are schema-driven.
 
 ## Context Window Management
 
@@ -1402,6 +1404,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             mcpTool('allow_tool'),
             mcpTool('list_allowed_tools'),
             mcpTool('disallow_tool'),
+            mcpTool('refresh_tool_inventory'),
             mcpTool('self_restart'),
             mcpTool('self_update'),
             mcpTool('where_is_source'),

package/dist/agent/mcp-bridge.js

@@ -386,7 +386,10 @@ export function getClaudeIntegrations() {
 }
 // ── SDK tool inventory probe ───────────────────────────────────────────
 const TOOL_INVENTORY_FILE = path.join(BASE_DIR, '.tool-inventory.json');
-const TOOL_INVENTORY_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24h
+// 1h TTL — short enough that a connector added at claude.ai propagates
+// within the hour without the user having to do anything. Forced refresh
+// via probeAvailableTools(true) is still available.
+const TOOL_INVENTORY_MAX_AGE_MS = 60 * 60 * 1000;
 export function loadToolInventory() {
     try {
         if (!existsSync(TOOL_INVENTORY_FILE))

package/dist/index.js

@@ -545,10 +545,22 @@ async function asyncMain() {
         const { checkPermissionsOnStartup, bootstrapClaudeIntegrationsFromAuditLog, probeAvailableTools } = await import('./agent/mcp-bridge.js');
         checkPermissionsOnStartup();
         bootstrapClaudeIntegrationsFromAuditLog(path.join(config.BASE_DIR, 'logs', 'audit.log'));
-        // Fire-and-forget: probe the SDK's full tool inventory so buildOptions
-        // knows everything Claude Code is surfacing (claude_ai_* connectors,
-        // plugins, etc.) without per-user hardcoding. Cached 24h.
-        probeAvailableTools().catch(() => { });
+        // Probe the SDK's full tool inventory so buildOptions knows everything
+        // Claude Code is surfacing (claude_ai_* connectors, plugins, etc.)
+        // without per-user hardcoding. Cached 1h. On fresh probe, log a short
+        // summary so the owner can verify which connectors were detected
+        // without having to ask the assistant.
+        probeAvailableTools().then(inv => {
+            const integrations = new Set();
+            for (const t of inv.tools) {
+                const m = t.match(/^mcp__claude_ai_([^_]+(?:_[^_]+)*)__/);
+                if (m)
+                    integrations.add(m[1].replace(/_/g, ' '));
+            }
+            if (integrations.size > 0) {
+                logger.info({ integrations: [...integrations].sort(), toolCount: inv.tools.length }, '🦞 Claude Desktop integrations detected');
+            }
+        }).catch(() => { });
     }
     catch { /* non-fatal */ }
     // ── Initialize layers ────────────────────────────────────────────

package/dist/tools/admin-tools.js

@@ -302,7 +302,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. Owner-DM only. Common case: Claude Desktop connector tools like mcp__claude_ai_Google_Drive__search_files that appear in the init inventory but aren\'t in your baseline whitelist.', {
+    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.', {
         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 }) => {
@@ -312,13 +312,28 @@ export function registerAdminTools(server) {
         const trimmed = name.trim();
         if (!trimmed)
             return textResult('Refused: empty tool name.');
-        // Loose format check — MCP tool names, built-in tool names, or namespaced patterns.
         if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(trimmed.replace(/__[A-Za-z0-9_-]+/g, ''))) {
             return textResult(`Refused: "${trimmed}" doesn't look like a valid tool name. Use a literal name like "mcp__claude_ai_Google_Drive__search_files" or a built-in like "WebFetch".`);
         }
+        // Auto-refresh inventory when the requested tool isn't in the cached
+        // inventory. This handles the "owner just added a connector at
+        // claude.ai" case without requiring them to wait for the hourly
+        // refresh or restart the daemon.
+        let refreshNote = '';
+        try {
+            const { probeAvailableTools } = await import('../agent/mcp-bridge.js');
+            const cached = (await import('../agent/mcp-bridge.js')).loadToolInventory();
+            if (!cached?.tools?.includes(trimmed)) {
+                const refreshed = await probeAvailableTools(true);
+                if (refreshed.tools.includes(trimmed)) {
+                    refreshNote = ' (picked up from a fresh probe — looks like the connector just came online)';
+                }
+            }
+        }
+        catch { /* non-fatal */ }
         const current = readExtraAllowedTools();
         if (current.includes(trimmed)) {
-            return textResult(`${trimmed} is already in your extra-allowed list. If it's still being refused, it may be disallowed by a higher-priority block (heartbeat/cron disallowed tools, profile tier).`);
+            return textResult(`${trimmed} is already in your extra-allowed list${refreshNote}. If it's still being refused, it may be disallowed by a higher-priority block (heartbeat/cron disallowed tools, profile tier).`);
         }
         current.push(trimmed);
         try {
@@ -328,7 +343,32 @@ export function registerAdminTools(server) {
             return textResult(`Failed to persist: ${String(err).slice(0, 200)}`);
         }
         logger.info({ name: trimmed, reason, totalExtras: current.length }, 'allow_tool');
-        return textResult(`Added ${trimmed} to ~/.clementine/allowed-tools-extra.json (${current.length} total extras). Active on your next query — no daemon restart needed.${reason ? ` Reason: ${reason}` : ''}`);
+        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 () => {
+        const gate = requireOwnerDm();
+        if (!gate.ok)
+            return textResult(gate.message);
+        try {
+            const { probeAvailableTools, loadToolInventory } = await import('../agent/mcp-bridge.js');
+            const before = loadToolInventory();
+            const beforeSet = new Set(before?.tools ?? []);
+            const after = await probeAvailableTools(true);
+            const afterSet = new Set(after.tools);
+            const added = [...afterSet].filter(t => !beforeSet.has(t));
+            const removed = [...beforeSet].filter(t => !afterSet.has(t));
+            const lines = [`Probed ${after.tools.length} tools.`];
+            if (added.length)
+                lines.push(`\n**Added since last probe:** ${added.length}\n${added.slice(0, 20).map(t => `- ${t}`).join('\n')}${added.length > 20 ? `\n... +${added.length - 20} more` : ''}`);
+            if (removed.length)
+                lines.push(`\n**Removed since last probe:** ${removed.length}\n${removed.slice(0, 10).map(t => `- ${t}`).join('\n')}`);
+            if (!added.length && !removed.length)
+                lines.push('No change since last probe.');
+            return textResult(lines.join('\n'));
+        }
+        catch (err) {
+            return textResult(`Probe failed: ${String(err).slice(0, 200)}`);
+        }
     });
     server.tool('list_allowed_tools', 'Show the current self-managed allowedTools extras (tools you added via allow_tool on top of the built-in whitelist). Owner-DM only.', {}, async () => {
         const gate = requireOwnerDm();

package/package.json

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