clementine-agent 1.18.43 → 1.18.44

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,24 @@ 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();
+    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',
+            },
+        },
+    };
     // Apply 1M-context env normalization (existing infra)
     const sdkOptionsRaw = {
         systemPrompt: profileAppend
@@ -90,9 +144,11 @@ export async function runAgent(prompt, opts) {
             : { type: 'preset', preset: 'claude_code' },
         settingSources: opts.settingSources ?? ['project'],
         agents,
+        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/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.44",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",