@lovelybunch/api 1.0.76-alpha.11 → 1.0.76-alpha.12

package/dist/routes/api/v1/ai/route.js

@@ -7,7 +7,7 @@ import { ZodError } from 'zod';
 import { streamText, tool, jsonSchema, stepCountIs } from 'ai';
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { getLogsDir, listTasks, getTask, createTask, updateTask, deleteTask, } from '@lovelybunch/core';
-import { tasksFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool, resourcesTool, listConnectorsTool, connectorRequestTool, resolveConnectorUrl } from '@lovelybunch/mcp';
+import { tasksFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, roleContextTool, agentsContextTool, teamContextTool, memoryContextTool, resourcesTool, listConnectorsTool, connectorRequestTool, resolveConnectorUrl } from '@lovelybunch/mcp';
 import matter from 'gray-matter';
 import Fuse from 'fuse.js';
 import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
@@ -120,27 +120,35 @@ export async function POST(c) {
                     return JSON.stringify(result);
                 },
             }),
-            project_context: tool({
-                description: projectContextTool.description,
-                inputSchema: jsonSchema(projectContextTool.parameters),
+            role_context: tool({
+                description: roleContextTool.description,
+                inputSchema: jsonSchema(roleContextTool.parameters),
                 execute: async (args) => {
-                    const result = await executeProjectContextToolDirect(args);
+                    const result = await executeRoleContextToolDirect(args);
                     return JSON.stringify(result);
                 },
             }),
-            architecture_context: tool({
-                description: architectureContextTool.description,
-                inputSchema: jsonSchema(architectureContextTool.parameters),
+            agents_context: tool({
+                description: agentsContextTool.description,
+                inputSchema: jsonSchema(agentsContextTool.parameters),
                 execute: async (args) => {
-                    const result = await executeArchitectureContextToolDirect(args);
+                    const result = await executeAgentsContextToolDirect(args);
                     return JSON.stringify(result);
                 },
             }),
-            role_context: tool({
-                description: roleContextTool.description,
-                inputSchema: jsonSchema(roleContextTool.parameters),
+            team_context: tool({
+                description: teamContextTool.description,
+                inputSchema: jsonSchema(teamContextTool.parameters),
                 execute: async (args) => {
-                    const result = await executeRoleContextToolDirect(args);
+                    const result = await executeTeamContextToolDirect(args);
+                    return JSON.stringify(result);
+                },
+            }),
+            memory_context: tool({
+                description: memoryContextTool.description,
+                inputSchema: jsonSchema(memoryContextTool.parameters),
+                execute: async (args) => {
+                    const result = await executeMemoryContextToolDirect(args);
                     return JSON.stringify(result);
                 },
             }),
@@ -537,12 +545,12 @@ async function executeEventsToolDirect(args) {
         return { success: false, error: error.message || 'Events tool execution failed' };
     }
 }
-// Project context tool - read/write the project definition document
-async function executeProjectContextToolDirect(args) {
+// Role context tool - read/write the role definition document
+async function executeRoleContextToolDirect(args) {
     const { operation, content, old_text, new_text } = args;
     try {
         const contextPath = getContextBasePath();
-        const filePath = join(contextPath, 'project.md');
+        const filePath = join(contextPath, 'role.md');
         switch (operation) {
             case 'get': {
                 try {
@@ -555,7 +563,7 @@ async function executeProjectContextToolDirect(args) {
                             frontmatter: parsed.data,
                             raw: fileContent
                         },
-                        message: 'Retrieved project context'
+                        message: 'Retrieved role context'
                     };
                 }
                 catch (err) {
@@ -563,7 +571,7 @@ async function executeProjectContextToolDirect(args) {
                         return {
                             success: true,
                             data: { content: '', frontmatter: {}, raw: '' },
-                            message: 'Project context document does not exist yet. You can create it with an update operation.'
+                            message: 'Role context document does not exist yet. You can create it with an update operation.'
                         };
                     }
                     throw err;
@@ -590,7 +598,7 @@ async function executeProjectContextToolDirect(args) {
                 await fs.writeFile(filePath, newContent, 'utf-8');
                 return {
                     success: true,
-                    message: 'Appended content to project context document'
+                    message: 'Appended content to role context document'
                 };
             }
             case 'replace_section': {
@@ -604,7 +612,7 @@ async function executeProjectContextToolDirect(args) {
                 }
                 catch (err) {
                     if (err.code === 'ENOENT') {
-                        return { success: false, error: 'Project context document does not exist. Use append or update to create it first.' };
+                        return { success: false, error: 'Role context document does not exist. Use append or update to create it first.' };
                     }
                     throw err;
                 }
@@ -614,7 +622,7 @@ async function executeProjectContextToolDirect(args) {
                         success: false,
                         error: 'Could not find the specified text in the document. The text may have been paraphrased or changed.',
                         fallback_markdown: new_text,
-                        suggestion: 'Here is the replacement text. You can copy it and manually edit the document at /context/project'
+                        suggestion: 'Here is the replacement text. You can copy it and manually edit the document at /context/role'
                     };
                 }
                 // Replace the text
@@ -622,7 +630,7 @@ async function executeProjectContextToolDirect(args) {
                 await fs.writeFile(filePath, updatedContent, 'utf-8');
                 return {
                     success: true,
-                    message: 'Replaced section in project context document'
+                    message: 'Replaced section in role context document'
                 };
             }
             case 'update': {
@@ -633,7 +641,7 @@ async function executeProjectContextToolDirect(args) {
                 await fs.writeFile(filePath, content, 'utf-8');
                 return {
                     success: true,
-                    message: 'Updated project context document'
+                    message: 'Updated role context document'
                 };
             }
             default:
@@ -641,124 +649,28 @@ async function executeProjectContextToolDirect(args) {
         }
     }
     catch (error) {
-        console.error('Error executing project context tool:', error);
-        return { success: false, error: error.message || 'Project context tool execution failed' };
+        console.error('Error executing role context tool:', error);
+        return { success: false, error: error.message || 'Role context tool execution failed' };
     }
 }
-// Architecture context tool - read/write the architecture document
-async function executeArchitectureContextToolDirect(args) {
-    const { operation, content, old_text, new_text } = args;
-    try {
-        const contextPath = getContextBasePath();
-        const filePath = join(contextPath, 'architecture.md');
-        switch (operation) {
-            case 'get': {
-                try {
-                    const fileContent = await fs.readFile(filePath, 'utf-8');
-                    const parsed = matter(fileContent);
-                    return {
-                        success: true,
-                        data: {
-                            content: parsed.content,
-                            frontmatter: parsed.data,
-                            raw: fileContent
-                        },
-                        message: 'Retrieved architecture context'
-                    };
-                }
-                catch (err) {
-                    if (err.code === 'ENOENT') {
-                        return {
-                            success: true,
-                            data: { content: '', frontmatter: {}, raw: '' },
-                            message: 'Architecture context document does not exist yet. You can create it with an update operation.'
-                        };
-                    }
-                    throw err;
-                }
-            }
-            case 'append': {
-                if (!content) {
-                    return { success: false, error: 'Content is required for append operation' };
-                }
-                await fs.mkdir(contextPath, { recursive: true });
-                // Read existing content if file exists
-                let existingContent = '';
-                try {
-                    existingContent = await fs.readFile(filePath, 'utf-8');
-                }
-                catch (err) {
-                    if (err.code !== 'ENOENT')
-                        throw err;
-                }
-                // Append new content with a newline separator
-                const newContent = existingContent
-                    ? existingContent.trimEnd() + '\n\n' + content
-                    : content;
-                await fs.writeFile(filePath, newContent, 'utf-8');
-                return {
-                    success: true,
-                    message: 'Appended content to architecture context document'
-                };
-            }
-            case 'replace_section': {
-                if (!old_text || !new_text) {
-                    return { success: false, error: 'Both old_text and new_text are required for replace_section operation' };
-                }
-                // Read existing content
-                let existingContent = '';
-                try {
-                    existingContent = await fs.readFile(filePath, 'utf-8');
-                }
-                catch (err) {
-                    if (err.code === 'ENOENT') {
-                        return { success: false, error: 'Architecture context document does not exist. Use append or update to create it first.' };
-                    }
-                    throw err;
-                }
-                // Check if old_text exists in the document
-                if (!existingContent.includes(old_text)) {
-                    return {
-                        success: false,
-                        error: 'Could not find the specified text in the document. The text may have been paraphrased or changed.',
-                        fallback_markdown: new_text,
-                        suggestion: 'Here is the replacement text. You can copy it and manually edit the document at /context/architecture'
-                    };
-                }
-                // Replace the text
-                const updatedContent = existingContent.replace(old_text, new_text);
-                await fs.writeFile(filePath, updatedContent, 'utf-8');
-                return {
-                    success: true,
-                    message: 'Replaced section in architecture context document'
-                };
-            }
-            case 'update': {
-                if (!content) {
-                    return { success: false, error: 'Content is required for update operation' };
-                }
-                await fs.mkdir(contextPath, { recursive: true });
-                await fs.writeFile(filePath, content, 'utf-8');
-                return {
-                    success: true,
-                    message: 'Updated architecture context document'
-                };
-            }
-            default:
-                return { success: false, error: `Unknown operation: ${operation}. Use 'get', 'append', 'replace_section', or 'update'.` };
-        }
-    }
-    catch (error) {
-        console.error('Error executing architecture context tool:', error);
-        return { success: false, error: error.message || 'Architecture context tool execution failed' };
-    }
+// Agents context tool - read/write the agents definition document
+async function executeAgentsContextToolDirect(args) {
+    return executeGenericContextToolDirect('agents', args);
 }
-// Role context tool - read/write the role definition document
-async function executeRoleContextToolDirect(args) {
+// Team context tool - read/write the team definition document
+async function executeTeamContextToolDirect(args) {
+    return executeGenericContextToolDirect('team', args);
+}
+// Memory context tool - read/write the memory document
+async function executeMemoryContextToolDirect(args) {
+    return executeGenericContextToolDirect('memory', args);
+}
+async function executeGenericContextToolDirect(contextType, args) {
     const { operation, content, old_text, new_text } = args;
+    const label = contextType.charAt(0).toUpperCase() + contextType.slice(1);
     try {
         const contextPath = getContextBasePath();
-        const filePath = join(contextPath, 'role.md');
+        const filePath = join(contextPath, `${contextType}.md`);
         switch (operation) {
             case 'get': {
                 try {
@@ -771,7 +683,7 @@ async function executeRoleContextToolDirect(args) {
                             frontmatter: parsed.data,
                             raw: fileContent
                         },
-                        message: 'Retrieved role context'
+                        message: `Retrieved ${contextType} context`
                     };
                 }
                 catch (err) {
@@ -779,7 +691,7 @@ async function executeRoleContextToolDirect(args) {
                         return {
                             success: true,
                             data: { content: '', frontmatter: {}, raw: '' },
-                            message: 'Role context document does not exist yet. You can create it with an update operation.'
+                            message: `${label} context document does not exist yet. You can create it with an update operation.`
                         };
                     }
                     throw err;
@@ -790,7 +702,6 @@ async function executeRoleContextToolDirect(args) {
                     return { success: false, error: 'Content is required for append operation' };
                 }
                 await fs.mkdir(contextPath, { recursive: true });
-                // Read existing content if file exists
                 let existingContent = '';
                 try {
                     existingContent = await fs.readFile(filePath, 'utf-8');
@@ -799,46 +710,42 @@ async function executeRoleContextToolDirect(args) {
                     if (err.code !== 'ENOENT')
                         throw err;
                 }
-                // Append new content with a newline separator
                 const newContent = existingContent
                     ? existingContent.trimEnd() + '\n\n' + content
                     : content;
                 await fs.writeFile(filePath, newContent, 'utf-8');
                 return {
                     success: true,
-                    message: 'Appended content to role context document'
+                    message: `Appended content to ${contextType} context document`
                 };
             }
             case 'replace_section': {
                 if (!old_text || !new_text) {
                     return { success: false, error: 'Both old_text and new_text are required for replace_section operation' };
                 }
-                // Read existing content
                 let existingContent = '';
                 try {
                     existingContent = await fs.readFile(filePath, 'utf-8');
                 }
                 catch (err) {
                     if (err.code === 'ENOENT') {
-                        return { success: false, error: 'Role context document does not exist. Use append or update to create it first.' };
+                        return { success: false, error: `${label} context document does not exist. Use append or update to create it first.` };
                     }
                     throw err;
                 }
-                // Check if old_text exists in the document
                 if (!existingContent.includes(old_text)) {
                     return {
                         success: false,
                         error: 'Could not find the specified text in the document. The text may have been paraphrased or changed.',
                         fallback_markdown: new_text,
-                        suggestion: 'Here is the replacement text. You can copy it and manually edit the document at /context/role'
+                        suggestion: `Here is the replacement text. You can copy it and manually edit the document at /context/${contextType}`
                     };
                 }
-                // Replace the text
                 const updatedContent = existingContent.replace(old_text, new_text);
                 await fs.writeFile(filePath, updatedContent, 'utf-8');
                 return {
                     success: true,
-                    message: 'Replaced section in role context document'
+                    message: `Replaced section in ${contextType} context document`
                 };
             }
             case 'update': {
@@ -849,7 +756,7 @@ async function executeRoleContextToolDirect(args) {
                 await fs.writeFile(filePath, content, 'utf-8');
                 return {
                     success: true,
-                    message: 'Updated role context document'
+                    message: `Updated ${contextType} context document`
                 };
             }
             default:
@@ -857,8 +764,8 @@ async function executeRoleContextToolDirect(args) {
         }
     }
     catch (error) {
-        console.error('Error executing role context tool:', error);
-        return { success: false, error: error.message || 'Role context tool execution failed' };
+        console.error(`Error executing ${contextType} context tool:`, error);
+        return { success: false, error: error.message || `${label} context tool execution failed` };
     }
 }
 // ─── Resources Tool ─────────────────────────────────────────────────────────

package/dist/routes/api/v1/jobs/[id]/route.d.ts

@@ -33,23 +33,20 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
             lastRunAt?: string;
             nextRunAt?: string;
         };
+        tags?: string[];
+        contextPaths?: string[];
+        agentId?: string;
+        agentIds?: string[];
+        mcpServers?: string[];
         runs: {
             id: string;
+            status: import("@lovelybunch/types").ScheduledJobRunStatus;
             jobId: string;
             trigger: import("@lovelybunch/types").ScheduledJobTrigger;
-            status: import("@lovelybunch/types").ScheduledJobRunStatus;
             startedAt: string;
             finishedAt?: string;
-            outputPath?: string;
-            summary?: string;
             error?: string;
-            cliCommand?: string;
         }[];
-        tags?: string[];
-        contextPaths?: string[];
-        agentId?: string;
-        agentIds?: string[];
-        mcpServers?: string[];
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;
@@ -97,23 +94,20 @@ export declare function PATCH(c: Context): Promise<(Response & import("hono").Ty
             lastRunAt?: string;
             nextRunAt?: string;
         };
+        tags?: string[];
+        contextPaths?: string[];
+        agentId?: string;
+        agentIds?: string[];
+        mcpServers?: string[];
         runs: {
             id: string;
+            status: import("@lovelybunch/types").ScheduledJobRunStatus;
             jobId: string;
             trigger: import("@lovelybunch/types").ScheduledJobTrigger;
-            status: import("@lovelybunch/types").ScheduledJobRunStatus;
             startedAt: string;
             finishedAt?: string;
-            outputPath?: string;
-            summary?: string;
             error?: string;
-            cliCommand?: string;
         }[];
-        tags?: string[];
-        contextPaths?: string[];
-        agentId?: string;
-        agentIds?: string[];
-        mcpServers?: string[];
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;

package/dist/routes/api/v1/jobs/[id]/route.js

@@ -1,6 +1,6 @@
 import { JobStore } from '../../../../../lib/jobs/job-store.js';
 import { getGlobalJobScheduler } from '../../../../../lib/jobs/global-job-scheduler.js';
-import { normalizeSchedule, normalizeStatus, } from '../route.js';
+import { normalizeSchedule, normalizeStatus, withLightweightRuns, } from '../route.js';
 const store = new JobStore();
 const scheduler = getGlobalJobScheduler();
 function normalizeScheduleUpdate(current, incoming) {
@@ -32,7 +32,7 @@ export async function GET(c) {
                 }
             }, 404);
         }
-        return c.json({ success: true, data: job });
+        return c.json({ success: true, data: withLightweightRuns(job) });
     }
     catch (error) {
         console.error('Failed to fetch job:', error);
@@ -101,7 +101,7 @@ export async function PATCH(c) {
         const reloaded = await store.getJob(updated.id);
         return c.json({
             success: true,
-            data: reloaded ?? updated
+            data: withLightweightRuns(reloaded ?? updated)
         });
     }
     catch (error) {

package/dist/routes/api/v1/jobs/route.d.ts

@@ -1,7 +1,13 @@
 import { Context } from 'hono';
-import { DayOfWeek, ScheduledJobSchedule, ScheduledJobStatus } from '@lovelybunch/types';
+import { DayOfWeek, ScheduledJobRun, ScheduledJobRunMeta, ScheduledJobSchedule, ScheduledJobStatus } from '@lovelybunch/types';
 export declare function normalizeSchedule(schedule?: Partial<ScheduledJobSchedule>): ScheduledJobSchedule;
 export declare function normalizeStatus(status?: ScheduledJobStatus): ScheduledJobStatus;
+export declare function toRunMeta(run: ScheduledJobRun): ScheduledJobRunMeta;
+export declare function withLightweightRuns<T extends {
+    runs: ScheduledJobRun[];
+}>(job: T): Omit<T, 'runs'> & {
+    runs: ScheduledJobRunMeta[];
+};
 export declare function GET(c: Context): Promise<(Response & import("hono").TypedResponse<{
     success: true;
     data: {
@@ -29,23 +35,20 @@ export declare function GET(c: Context): Promise<(Response & import("hono").Type
             lastRunAt?: string;
             nextRunAt?: string;
         };
+        tags?: string[];
+        contextPaths?: string[];
+        agentId?: string;
+        agentIds?: string[];
+        mcpServers?: string[];
         runs: {
             id: string;
+            status: import("@lovelybunch/types").ScheduledJobRunStatus;
             jobId: string;
             trigger: import("@lovelybunch/types").ScheduledJobTrigger;
-            status: import("@lovelybunch/types").ScheduledJobRunStatus;
             startedAt: string;
             finishedAt?: string;
-            outputPath?: string;
-            summary?: string;
             error?: string;
-            cliCommand?: string;
         }[];
-        tags?: string[];
-        contextPaths?: string[];
-        agentId?: string;
-        agentIds?: string[];
-        mcpServers?: string[];
     }[];
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
     success: false;
@@ -87,23 +90,20 @@ export declare function POST(c: Context): Promise<(Response & import("hono").Typ
             lastRunAt?: string;
             nextRunAt?: string;
         };
+        tags?: string[];
+        contextPaths?: string[];
+        agentId?: string;
+        agentIds?: string[];
+        mcpServers?: string[];
         runs: {
             id: string;
+            status: import("@lovelybunch/types").ScheduledJobRunStatus;
             jobId: string;
             trigger: import("@lovelybunch/types").ScheduledJobTrigger;
-            status: import("@lovelybunch/types").ScheduledJobRunStatus;
             startedAt: string;
             finishedAt?: string;
-            outputPath?: string;
-            summary?: string;
             error?: string;
-            cliCommand?: string;
         }[];
-        tags?: string[];
-        contextPaths?: string[];
-        agentId?: string;
-        agentIds?: string[];
-        mcpServers?: string[];
     };
 }, 201, "json">) | (Response & import("hono").TypedResponse<{
     success: false;

package/dist/routes/api/v1/jobs/route.js

@@ -58,12 +58,27 @@ export function normalizeSchedule(schedule) {
 export function normalizeStatus(status) {
     return status === 'active' ? 'active' : 'paused';
 }
+export function toRunMeta(run) {
+    return {
+        id: run.id,
+        jobId: run.jobId,
+        trigger: run.trigger,
+        status: run.status,
+        startedAt: run.startedAt,
+        finishedAt: run.finishedAt,
+        error: run.error,
+    };
+}
+export function withLightweightRuns(job) {
+    const { runs, ...rest } = job;
+    return { ...rest, runs: runs.map(toRunMeta) };
+}
 export async function GET(c) {
     try {
         const jobs = await store.listJobs();
         return c.json({
             success: true,
-            data: jobs
+            data: jobs.map(withLightweightRuns)
         });
     }
     catch (error) {
@@ -131,7 +146,7 @@ export async function POST(c) {
         const created = await store.getJob(job.id);
         return c.json({
             success: true,
-            data: created ?? job
+            data: withLightweightRuns(created ?? job)
         }, 201);
     }
     catch (error) {

package/dist/routes/api/v1/mcp/index.js

@@ -3,7 +3,7 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import { ZodError } from 'zod';
 import { listTasks, getTask, createTask, updateTask, deleteTask, getContext, updateContext, appendContext, replaceContextSection, listKnowledge, getKnowledge, createKnowledge, updateKnowledge, listEvents, } from '@lovelybunch/core';
-import { tasksFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, projectContextTool, architectureContextTool, roleContextTool, resourcesTool, listConnectorsTool, connectorRequestTool, resolveConnectorUrl } from '@lovelybunch/mcp';
+import { tasksFullTool, knowledgeTool, normalizeKnowledgeMetadata, eventsTool, roleContextTool, agentsContextTool, teamContextTool, memoryContextTool, resourcesTool, listConnectorsTool, connectorRequestTool, resolveConnectorUrl } from '@lovelybunch/mcp';
 import { FileStorageAdapter } from '../../../../lib/storage/file-storage.js';
 import { homedir } from 'os';
 import { readFileSync, existsSync } from 'fs';
@@ -104,14 +104,15 @@ app.get('/', async (c) => {
         }
         const names = Object.keys(externalServers);
         // Add built-in tools (include full JSON schema for parameters)
-        // Note: tasks now supports full CRUD, knowledge/project/architecture are read+write, events is read-only
+        // Note: tasks now supports full CRUD, knowledge/context tools are read+write, events is read-only
         const builtInTools = {
             tasks: tasksFullTool,
             knowledge_documents: knowledgeTool,
             activity_events: eventsTool,
-            project_context: projectContextTool,
-            architecture_context: architectureContextTool,
             role_context: roleContextTool,
+            agents_context: agentsContextTool,
+            team_context: teamContextTool,
+            memory_context: memoryContextTool,
             resources: resourcesTool,
             list_connectors: listConnectorsTool,
             connector_request: connectorRequestTool
@@ -134,15 +135,16 @@ app.get('/', async (c) => {
  */
 app.get('/schema', async (c) => {
     try {
-        // Note: tasks now supports full CRUD, knowledge/project/architecture are read+write, events is read-only
+        // Note: tasks now supports full CRUD, knowledge/context tools are read+write, events is read-only
         const schema = {
             tools: {
                 tasks: tasksFullTool,
                 knowledge_documents: knowledgeTool,
                 activity_events: eventsTool,
-                project_context: projectContextTool,
-                architecture_context: architectureContextTool,
                 role_context: roleContextTool,
+                agents_context: agentsContextTool,
+                team_context: teamContextTool,
+                memory_context: memoryContextTool,
                 resources: resourcesTool,
                 list_connectors: listConnectorsTool,
                 connector_request: connectorRequestTool
@@ -174,15 +176,18 @@ app.post('/execute', async (c) => {
         if (tool === 'activity_events') {
             return await executeEventsTool(c, args);
         }
-        if (tool === 'project_context') {
-            return await executeProjectContextTool(c, args);
-        }
-        if (tool === 'architecture_context') {
-            return await executeArchitectureContextTool(c, args);
-        }
         if (tool === 'role_context') {
             return await executeRoleContextTool(c, args);
         }
+        if (tool === 'agents_context') {
+            return await executeAgentsContextTool(c, args);
+        }
+        if (tool === 'team_context') {
+            return await executeTeamContextTool(c, args);
+        }
+        if (tool === 'memory_context') {
+            return await executeMemoryContextTool(c, args);
+        }
         if (tool === 'resources') {
             return await executeResourcesTool(c, args);
         }
@@ -482,15 +487,18 @@ async function executeContextTool(c, contextType, args) {
     }
 }
 // Wrapper functions for each context type (maintain API compatibility)
-async function executeProjectContextTool(c, args) {
-    return executeContextTool(c, 'project', args);
-}
-async function executeArchitectureContextTool(c, args) {
-    return executeContextTool(c, 'architecture', args);
-}
 async function executeRoleContextTool(c, args) {
     return executeContextTool(c, 'role', args);
 }
+async function executeAgentsContextTool(c, args) {
+    return executeContextTool(c, 'agents', args);
+}
+async function executeTeamContextTool(c, args) {
+    return executeContextTool(c, 'team', args);
+}
+async function executeMemoryContextTool(c, args) {
+    return executeContextTool(c, 'memory', args);
+}
 // Resources tool executor — proxies to the resource API endpoints on the same server
 async function executeResourcesTool(c, args) {
     const { operation, query, type_filter, resource_id, prompt, model, aspect_ratio, text, voice, duration, resolution, url, tags, description } = args;