clementine-agent 1.18.43 → 1.18.45

package/dist/agent/assistant.d.ts

@@ -277,6 +277,13 @@ export declare class PersonalAssistant {
     private memoryExtractionKey;
     private assessMemoryExtraction;
     private logMemoryExtractionSkip;
+    /**
+     * Public entry point for triggering auto-memory extraction after an
+     * exchange. Used by the new runAgent chat path (Phase 2 migration)
+     * so it can keep the existing memory-extraction behavior without
+     * having to recreate the surrounding plumbing.
+     */
+    triggerMemoryExtractionPostExchange(userMessage: string, assistantResponse: string, sessionKey?: string, profile?: AgentProfile): Promise<void>;
     private spawnMemoryExtraction;
     private static readonly MEMORY_TOOL_NAMES;
     private extractMemory;

package/dist/agent/assistant.js

@@ -4883,6 +4883,15 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         }
         catch { /* telemetry only */ }
     }
+    /**
+     * Public entry point for triggering auto-memory extraction after an
+     * exchange. Used by the new runAgent chat path (Phase 2 migration)
+     * so it can keep the existing memory-extraction behavior without
+     * having to recreate the surrounding plumbing.
+     */
+    async triggerMemoryExtractionPostExchange(userMessage, assistantResponse, sessionKey, profile) {
+        return this.spawnMemoryExtraction(userMessage, assistantResponse, sessionKey, profile);
+    }
     async spawnMemoryExtraction(userMessage, assistantResponse, sessionKey, profile) {
         // Guard: skip memory extraction if the user message looks like injection
         const memScan = scanner.scan(userMessage);

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

@@ -66,6 +66,17 @@ export interface RunAgentOptions {
     allowedTools?: string[];
     /** Optional CLAUDE.md / project setting source. Defaults to ['project']. */
     settingSources?: ('project' | 'user' | 'local')[];
+    /** Additional MCP servers to merge with the always-on clementine-tools
+     *  server. Use to wire Composio + claude.ai integrations on chat-path
+     *  invocations that need Outlook/Salesforce/etc. */
+    extraMcpServers?: Record<string, {
+        type: 'stdio' | 'http' | 'sse';
+        command?: string;
+        args?: string[];
+        env?: Record<string, string>;
+        url?: string;
+        headers?: Record<string, string>;
+    }>;
 }
 export interface RunAgentResult {
     /** Final text response from the agent. */

package/dist/agent/run-agent.js

@@ -21,10 +21,46 @@
  * 5. NO context-thrash recovery, NO manual session rotation, NO
  *    long-task preflight, NO mode=unleashed wrapper.
  */
+import path from 'node:path';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import pino from 'pino';
-import { BASE_DIR, normalizeClaudeSdkOptionsForOneMillionContext } from '../config.js';
+import { BASE_DIR, PKG_DIR, CLAUDE_CODE_OAUTH_TOKEN, ANTHROPIC_API_KEY as CONFIG_ANTHROPIC_API_KEY, normalizeClaudeSdkOptionsForOneMillionContext, } from '../config.js';
 import { buildAgentMap } from './agent-definitions.js';
+const MCP_SERVER_SCRIPT = path.join(PKG_DIR, 'dist', 'tools', 'mcp-server.js');
+const ASSISTANT_NAME = (process.env.ASSISTANT_NAME ?? 'Clementine').toLowerCase();
+const TOOLS_SERVER = `${ASSISTANT_NAME}-tools`;
+/**
+ * Build a minimal env for the SDK subprocess. Mirrors the existing
+ * SAFE_ENV pattern in assistant.ts but exposed here so runAgent can be
+ * its own thing without depending on the legacy assistant module.
+ *
+ * Priority: CLAUDE_CODE_OAUTH_TOKEN > ANTHROPIC_AUTH_TOKEN > ANTHROPIC_API_KEY.
+ * When all are absent, HOME lets the subprocess find Keychain OAuth.
+ */
+function buildRunAgentEnv() {
+    const env = {
+        PATH: process.env.PATH ?? '',
+        HOME: process.env.HOME ?? '',
+        LANG: process.env.LANG ?? 'en_US.UTF-8',
+        TERM: process.env.TERM ?? 'xterm-256color',
+        USER: process.env.USER ?? '',
+        SHELL: process.env.SHELL ?? '',
+        CLEMENTINE_HOME: BASE_DIR,
+    };
+    const oauthTok = CLAUDE_CODE_OAUTH_TOKEN || process.env.CLAUDE_CODE_OAUTH_TOKEN;
+    const authTok = process.env.ANTHROPIC_AUTH_TOKEN;
+    const apiKey = CONFIG_ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY;
+    if (oauthTok) {
+        env.CLAUDE_CODE_OAUTH_TOKEN = oauthTok;
+    }
+    else if (authTok) {
+        env.ANTHROPIC_AUTH_TOKEN = authTok;
+    }
+    else if (apiKey) {
+        env.ANTHROPIC_API_KEY = apiKey;
+    }
+    return env;
+}
 const logger = pino({ name: 'clementine.run-agent' });
 const DEFAULT_BUDGETS = {
     chat: 0.50,
@@ -83,6 +119,28 @@ export async function runAgent(prompt, opts) {
     // Allowed tools. Default to core + Clementine MCP. Per-subagent tool
     // restrictions live on each AgentDefinition.tools field.
     const allowedTools = opts.allowedTools ?? CORE_TOOLS_FOR_AGENT_PARENT;
+    // Wire the Clementine MCP server so the agent can reach memory/cron/
+    // broken-job tools. Without this, the cron-fixer subagent's `tools`
+    // list references mcp__clementine-tools__* that don't exist in the
+    // session, and the agent falls back to reading raw JSON files.
+    const subprocessEnv = buildRunAgentEnv();
+    // SDK accepts a Record<string, McpServerConfig> here. We cast on
+    // assignment because we mix the always-on Clementine stdio server
+    // with caller-supplied servers of various types.
+    const mcpServers = {
+        [TOOLS_SERVER]: {
+            type: 'stdio',
+            command: 'node',
+            args: [MCP_SERVER_SCRIPT],
+            env: {
+                ...subprocessEnv,
+                CLEMENTINE_HOME: BASE_DIR,
+                ...(opts.profile?.slug ? { CLEMENTINE_TEAM_AGENT: opts.profile.slug } : {}),
+                CLEMENTINE_INTERACTION_SOURCE: source === 'cron' || source === 'heartbeat' ? 'autonomous' : 'interactive',
+            },
+        },
+        ...(opts.extraMcpServers ?? {}),
+    };
     // Apply 1M-context env normalization (existing infra)
     const sdkOptionsRaw = {
         systemPrompt: profileAppend
@@ -90,9 +148,13 @@ export async function runAgent(prompt, opts) {
             : { type: 'preset', preset: 'claude_code' },
         settingSources: opts.settingSources ?? ['project'],
         agents,
+        // SDK's McpServerConfig is a union; cast at the boundary since
+        // callers can mix stdio + http + sse server shapes.
+        mcpServers: mcpServers,
         allowedTools,
         permissionMode: 'bypassPermissions',
         cwd: BASE_DIR,
+        env: subprocessEnv,
         maxBudgetUsd,
         effort,
         ...(opts.maxTurns ? { maxTurns: opts.maxTurns } : {}),

package/dist/cli/dashboard.js

@@ -2347,7 +2347,8 @@ export async function cmdDashboard(opts) {
         const isLongRunning = req.path.startsWith('/brain/')
             || req.path.endsWith('/stream')
             || req.path === '/chat'
-            || req.path === '/builder/chat';
+            || req.path === '/builder/chat'
+            || req.path === '/runagent/test';
         const timeoutMs = isLongRunning ? 10 * 60 * 1000 : 8000;
         const timeout = setTimeout(() => {
             if (!res.headersSent) {

package/dist/gateway/router.js

@@ -2088,6 +2088,79 @@ export class Gateway {
                     delete sessState.pendingInterrupt;
                 }
                 try {
+                    // ── Phase 2: opt-in canonical SDK chat path ──────────────────
+                    // When CLEMENTINE_USE_RUNAGENT_CHAT=1 is set, route through
+                    // the new runAgent() wrapper instead of the legacy
+                    // assistant.chat path. This is the SDK-canonical pattern
+                    // (one query() call, agents map for subagents, no
+                    // wrapper layers). Today's Phase 2 connects only the
+                    // Clementine MCP server — Composio/external integrations
+                    // come in Phase 3. Useful for testing the new path on
+                    // tool-light sessions like cron-fix or memory queries.
+                    //
+                    // The legacy path (default) keeps full Composio/external
+                    // routing + all post-response handlers, so this flag is
+                    // safe to leave off until we're ready.
+                    if (process.env.CLEMENTINE_USE_RUNAGENT_CHAT === '1'
+                        && this.isTrustedPersonalSession(sessionKey)
+                        && !sessState.pendingInterrupt) {
+                        const { runAgent } = await import('../agent/run-agent.js');
+                        logger.info({
+                            sessionKey: effectiveSessionKey,
+                            profile: resolvedProfile?.slug,
+                            path: 'runagent_chat',
+                        }, 'Phase 2: routing chat through runAgent');
+                        try {
+                            const runAgentResult = await runAgent(originalText, {
+                                sessionKey: effectiveSessionKey,
+                                source: 'chat',
+                                profile: resolvedProfile,
+                                agentManager: this.getAgentManager(),
+                                memoryStore: this.assistant.getMemoryStore?.() ?? null,
+                                onText: wrappedOnText,
+                                onToolActivity: ({ tool, input }) => {
+                                    toolActivityCount++;
+                                    if (wrappedOnToolActivity) {
+                                        return wrappedOnToolActivity(tool, input);
+                                    }
+                                    return undefined;
+                                },
+                                abortSignal: chatAc.signal,
+                            });
+                            clearTimeout(chatTimer);
+                            clearTimeout(hardWallTimer);
+                            // Mirror transcript so memory + recall continue working.
+                            const memoryStore = this.assistant.getMemoryStore?.();
+                            if (memoryStore) {
+                                try {
+                                    memoryStore.saveTurn(effectiveSessionKey, 'user', originalText);
+                                    memoryStore.saveTurn(effectiveSessionKey, 'assistant', runAgentResult.text);
+                                }
+                                catch (err) {
+                                    logger.debug({ err }, 'runAgent chat: transcript mirror failed (non-fatal)');
+                                }
+                            }
+                            // Fire auto-memory extraction in the background so
+                            // MEMORY.md continues to update like the legacy path.
+                            this.assistant
+                                .triggerMemoryExtractionPostExchange(originalText, runAgentResult.text, effectiveSessionKey, resolvedProfile)
+                                .catch(err => logger.debug({ err, sessionKey: effectiveSessionKey }, 'runAgent chat: auto-memory failed (non-fatal)'));
+                            logger.info({
+                                sessionKey: effectiveSessionKey,
+                                totalMs: Date.now() - tInnerStart,
+                                routedVia: 'runagent_chat',
+                                numTurns: runAgentResult.numTurns,
+                                cost: Number(runAgentResult.totalCostUsd.toFixed(4)),
+                                responseLen: runAgentResult.text.length,
+                            }, 'chat:latency');
+                            return runAgentResult.text;
+                        }
+                        catch (err) {
+                            logger.warn({ err, sessionKey: effectiveSessionKey }, 'runAgent chat path failed — falling back to legacy chat');
+                            // Fall through to the legacy chat path so the user
+                            // still gets a response.
+                        }
+                    }
                     // ── Pre-LLM plan routing (Gap #3 from orchestration audit) ──
                     // When the user's text clearly maps to multi-step parallel
                     // work, route through the orchestrator BEFORE the main agent

package/dist/tools/admin-tools.js

@@ -1170,147 +1170,14 @@ export function registerAdminTools(server) {
         return textResult(`Triggered "${job_name}" — the daemon will pick it up within a few seconds and run it in the background. ` +
             `Results will be delivered via notifications when complete.`);
     });
-    // ── Workflow Tools ──────────────────────────────────────────────────────
-    const WORKFLOWS_DIR = path.join(SYSTEM_DIR, 'workflows');
-    server.tool('workflow_list', 'List all multi-step workflows with name, description, step count, trigger, and enabled status.', { _empty: z.string().optional().describe('(no parameters needed)') }, async () => {
-        if (!existsSync(WORKFLOWS_DIR)) {
-            return textResult('No workflows directory found. Create `vault/00-System/workflows/` and add workflow .md files.');
-        }
-        const { parseAllWorkflows } = await import('../agent/workflow-runner.js');
-        const workflows = parseAllWorkflows(WORKFLOWS_DIR);
-        if (workflows.length === 0) {
-            return textResult('No workflow files found in `vault/00-System/workflows/`.');
-        }
-        const lines = [];
-        for (const wf of workflows) {
-            const status = wf.enabled ? 'enabled' : 'disabled';
-            const trigger = wf.trigger.schedule ? `schedule: \`${wf.trigger.schedule}\`` : 'manual only';
-            lines.push(`**${wf.name}** [${status}]` +
-                `\n  ${wf.description || '(no description)'}` +
-                `\n  Trigger: ${trigger}` +
-                `\n  Steps (${wf.steps.length}): ${wf.steps.map(s => s.id).join(' → ')}` +
-                (Object.keys(wf.inputs).length > 0
-                    ? `\n  Inputs: ${Object.entries(wf.inputs).map(([k, v]) => `${k}${v.default ? `="${v.default}"` : ''}`).join(', ')}`
-                    : ''));
-        }
-        return textResult(lines.join('\n\n'));
-    });
-    server.tool('workflow_create', 'Create a new multi-step workflow file. Validates dependencies and writes to vault/00-System/workflows/. The daemon auto-reloads on file change.', {
-        name: z.string().describe('Workflow name (used as filename and identifier)'),
-        description: z.string().describe('What the workflow does'),
-        steps: z.array(z.object({
-            id: z.string().describe('Unique step identifier'),
-            prompt: z.string().describe('Prompt for the step (supports {{input.*}}, {{steps.*.output}}, {{date}} variables)'),
-            dependsOn: z.array(z.string()).default([]).describe('Step IDs this depends on'),
-            model: z.string().optional().describe('Model tier: haiku or sonnet'),
-            tier: z.number().optional().default(1).describe('Security tier (1-3)'),
-            maxTurns: z.number().optional().default(15).describe('Max agent turns'),
-        })).describe('Workflow steps'),
-        trigger_schedule: z.string().optional().describe('Cron expression for scheduled trigger'),
-        inputs: z.record(z.string(), z.object({
-            type: z.enum(['string', 'number']).default('string'),
-            default: z.string().optional(),
-            description: z.string().optional(),
-        })).optional().default({}).describe('Input parameters with optional defaults'),
-        synthesis_prompt: z.string().optional().describe('Prompt to synthesize final output from all step results'),
-    }, async ({ name, description, steps, trigger_schedule, inputs, synthesis_prompt }) => {
-        // Validate step IDs are unique
-        const ids = new Set(steps.map(s => s.id));
-        if (ids.size !== steps.length) {
-            return textResult('Error: Duplicate step IDs found.');
-        }
-        // Validate dependencies exist
-        for (const step of steps) {
-            for (const dep of step.dependsOn) {
-                if (!ids.has(dep)) {
-                    return textResult(`Error: Step "${step.id}" depends on unknown step "${dep}".`);
-                }
-            }
-        }
-        // Validate cron expression if provided
-        if (trigger_schedule) {
-            const cronMod = await import('node-cron');
-            if (!cronMod.default.validate(trigger_schedule)) {
-                return textResult(`Invalid cron expression: "${trigger_schedule}".`);
-            }
-        }
-        // Build frontmatter
-        const frontmatter = {
-            type: 'workflow',
-            name,
-            description,
-            enabled: true,
-            trigger: {
-                ...(trigger_schedule ? { schedule: trigger_schedule } : {}),
-                manual: true,
-            },
-        };
-        if (Object.keys(inputs).length > 0) {
-            frontmatter.inputs = inputs;
-        }
-        frontmatter.steps = steps.map(s => ({
-            id: s.id,
-            prompt: s.prompt,
-            dependsOn: s.dependsOn,
-            ...(s.model ? { model: s.model } : {}),
-            ...(s.tier && s.tier !== 1 ? { tier: s.tier } : {}),
-            ...(s.maxTurns && s.maxTurns !== 15 ? { maxTurns: s.maxTurns } : {}),
-        }));
-        if (synthesis_prompt) {
-            frontmatter.synthesis = { prompt: synthesis_prompt };
-        }
-        // Write file
-        if (!existsSync(WORKFLOWS_DIR)) {
-            mkdirSync(WORKFLOWS_DIR, { recursive: true });
-        }
-        const matterMod = await import('gray-matter');
-        const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '-').toLowerCase();
-        const filePath = path.join(WORKFLOWS_DIR, `${safeName}.md`);
-        if (existsSync(filePath)) {
-            return textResult(`Workflow file already exists: ${safeName}.md. Delete or rename it first.`);
-        }
-        const body = `# ${name}\n\n${description}\n`;
-        const output = matterMod.default.stringify(body, frontmatter);
-        writeFileSync(filePath, output);
-        logger.info({ name, steps: steps.length }, 'Created workflow via MCP tool');
-        const goalHint = `\n\n💡 **Goal tracking:** What goal does this workflow serve? Consider creating a persistent goal (\`goal_create\`) and linking related cron jobs so self-improvement can optimize this workflow against measurable outcomes.`;
-        return textResult(`Created workflow "${name}" with ${steps.length} steps.\n` +
-            `File: vault/00-System/workflows/${safeName}.md\n` +
-            `Steps: ${steps.map(s => s.id).join(' → ')}\n` +
-            (trigger_schedule ? `Schedule: ${trigger_schedule}\n` : 'Trigger: manual\n') +
-            'The daemon will auto-detect it via file watcher.' +
-            goalHint);
-    });
-    server.tool('workflow_run', 'Trigger a workflow by name with optional input overrides. Returns the workflow result.', {
-        name: z.string().describe('Workflow name'),
-        inputs: z.record(z.string(), z.string()).optional().default({}).describe('Input overrides (key=value pairs)'),
-    }, async ({ name: workflowName, inputs }) => {
-        const { parseAllWorkflows } = await import('../agent/workflow-runner.js');
-        const { WorkflowRunner } = await import('../agent/workflow-runner.js');
-        const workflows = parseAllWorkflows(WORKFLOWS_DIR);
-        const wf = workflows.find(w => w.name === workflowName);
-        if (!wf) {
-            const available = workflows.map(w => w.name).join(', ');
-            return textResult(`Workflow "${workflowName}" not found. Available: ${available || 'none'}`);
-        }
-        if (!wf.enabled) {
-            return textResult(`Workflow "${workflowName}" is disabled.`);
-        }
-        // Build a minimal assistant for standalone MCP execution
-        // In daemon mode, the CronScheduler.runWorkflow() path is preferred
-        // For MCP standalone, we need to create an assistant instance
-        try {
-            const { PersonalAssistant } = await import('../agent/assistant.js');
-            const assistant = new PersonalAssistant();
-            const runner = new WorkflowRunner(assistant);
-            const result = await runner.run(wf, inputs);
-            return textResult(`**Workflow: ${workflowName}** — ${result.status}\n\n${result.output.slice(0, 3000)}`);
-        }
-        catch (err) {
-            logger.error({ err, workflow: workflowName }, 'Workflow execution failed');
-            return textResult(`Workflow "${workflowName}" failed: ${err instanceof Error ? err.message : err}`);
-        }
-    });
+    // ── Workflow Tools moved to builder-tools.ts ────────────────────────────
+    //
+    // `workflow_list`, `workflow_create`, and `workflow_run` were duplicated
+    // here AND in builder-tools.ts (the newer Trick Builder). The duplicate
+    // registration was crashing the MCP server on startup with
+    // "Tool X is already registered" — silently breaking every fresh MCP
+    // subprocess and forcing fallback to manual file reads.
+    // All three live in builder-tools.ts now.
     // ── Analyze Image ───────────────────────────────────────────────────────
     server.tool('analyze_image', 'Analyze an image by URL. Fetches the image, converts to base64, and uses Claude vision to describe it. Works with any image URL — channel attachments, email attachments, web images.', {
         url: z.string().describe('URL of the image to analyze'),

package/package.json

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