@elizaos/plugin-linear 1.2.13 → 2.0.0-alpha.1

package/dist/index.js

@@ -1,420 +1,105 @@
-// src/services/linear.ts
-import { logger, Service } from "@elizaos/core";
-import { LinearClient } from "@linear/sdk";
-
-// src/types/index.ts
-var LinearAPIError = class extends Error {
-  constructor(message, status, response) {
-    super(message);
-    this.status = status;
-    this.response = response;
-    this.name = "LinearAPIError";
-  }
-};
-var LinearAuthenticationError = class extends LinearAPIError {
-  constructor(message) {
-    super(message, 401);
-    this.name = "LinearAuthenticationError";
-  }
-};
-var LinearRateLimitError = class extends LinearAPIError {
-  constructor(message, resetTime) {
-    super(message, 429);
-    this.resetTime = resetTime;
-    this.name = "LinearRateLimitError";
-  }
-};
-
-// src/services/linear.ts
-var _LinearService = class _LinearService extends Service {
-  constructor(runtime) {
-    super(runtime);
-    this.capabilityDescription = "Linear API integration for issue tracking, project management, and team collaboration";
-    this.activityLog = [];
-    const apiKey = runtime?.getSetting("LINEAR_API_KEY");
-    const workspaceId = runtime?.getSetting("LINEAR_WORKSPACE_ID");
-    if (!apiKey) {
-      throw new LinearAuthenticationError("Linear API key is required");
-    }
-    this.linearConfig = {
-      LINEAR_API_KEY: apiKey,
-      LINEAR_WORKSPACE_ID: workspaceId
-    };
-    this.workspaceId = workspaceId;
-    this.config = {
-      LINEAR_API_KEY: apiKey,
-      LINEAR_WORKSPACE_ID: workspaceId
-    };
-    this.client = new LinearClient({
-      apiKey: this.linearConfig.LINEAR_API_KEY
-    });
-  }
-  static async start(runtime) {
-    const service = new _LinearService(runtime);
-    await service.validateConnection();
-    logger.info("Linear service started successfully");
-    return service;
-  }
-  async stop() {
-    this.activityLog = [];
-    logger.info("Linear service stopped");
-  }
-  // Validate the API connection
-  async validateConnection() {
-    try {
-      const viewer = await this.client.viewer;
-      logger.info(`Linear connected as user: ${viewer.email}`);
-    } catch (error) {
-      throw new LinearAuthenticationError("Failed to authenticate with Linear API");
-    }
-  }
-  // Log activity
-  logActivity(action, resourceType, resourceId, details, success, error) {
-    const activity = {
-      id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      action,
-      resource_type: resourceType,
-      resource_id: resourceId,
-      details,
-      success,
-      error
-    };
-    this.activityLog.push(activity);
-    if (this.activityLog.length > 1e3) {
-      this.activityLog = this.activityLog.slice(-1e3);
-    }
-  }
-  // Get activity log
-  getActivityLog(limit, filter) {
-    let filtered = [...this.activityLog];
-    if (filter) {
-      filtered = filtered.filter((item) => {
-        return Object.entries(filter).every(([key, value]) => {
-          return item[key] === value;
-        });
-      });
-    }
-    return filtered.slice(-(limit || 100));
-  }
-  // Clear activity log
-  clearActivityLog() {
-    this.activityLog = [];
-    logger.info("Linear activity log cleared");
-  }
-  // Team operations
-  async getTeams() {
-    try {
-      const teams = await this.client.teams();
-      const teamList = await teams.nodes;
-      this.logActivity("list_teams", "team", "all", { count: teamList.length }, true);
-      return teamList;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      this.logActivity("list_teams", "team", "all", {}, false, errorMessage);
-      throw new LinearAPIError(`Failed to fetch teams: ${errorMessage}`);
-    }
-  }
-  async getTeam(teamId) {
-    try {
-      const team = await this.client.team(teamId);
-      this.logActivity("get_team", "team", teamId, { name: team.name }, true);
-      return team;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      this.logActivity("get_team", "team", teamId, {}, false, errorMessage);
-      throw new LinearAPIError(`Failed to fetch team: ${errorMessage}`);
-    }
-  }
-  // Issue operations
-  async createIssue(input) {
-    try {
-      const issuePayload = await this.client.createIssue({
-        title: input.title,
-        description: input.description,
-        teamId: input.teamId,
-        priority: input.priority,
-        assigneeId: input.assigneeId,
-        labelIds: input.labelIds,
-        projectId: input.projectId,
-        stateId: input.stateId,
-        estimate: input.estimate,
-        dueDate: input.dueDate
-      });
-      const issue = await issuePayload.issue;
-      if (!issue) {
-        throw new Error("Failed to create issue");
-      }
-      this.logActivity("create_issue", "issue", issue.id, {
-        title: input.title,
-        teamId: input.teamId
-      }, true);
-      return issue;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      this.logActivity("create_issue", "issue", "new", input, false, errorMessage);
-      throw new LinearAPIError(`Failed to create issue: ${errorMessage}`);
-    }
-  }
-  async getIssue(issueId) {
-    try {
-      const issue = await this.client.issue(issueId);
-      this.logActivity("get_issue", "issue", issueId, {
-        title: issue.title,
-        identifier: issue.identifier
-      }, true);
-      return issue;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      this.logActivity("get_issue", "issue", issueId, {}, false, errorMessage);
-      throw new LinearAPIError(`Failed to fetch issue: ${errorMessage}`);
-    }
-  }
-  async updateIssue(issueId, updates) {
-    try {
-      const updatePayload = await this.client.updateIssue(issueId, {
-        title: updates.title,
-        description: updates.description,
-        priority: updates.priority,
-        assigneeId: updates.assigneeId,
-        labelIds: updates.labelIds,
-        projectId: updates.projectId,
-        stateId: updates.stateId,
-        estimate: updates.estimate,
-        dueDate: updates.dueDate
-      });
-      const issue = await updatePayload.issue;
-      if (!issue) {
-        throw new Error("Failed to update issue");
+// src/actions/clearActivity.ts
+import {
+  logger
+} from "@elizaos/core";
+var clearActivityAction = {
+  name: "CLEAR_LINEAR_ACTIVITY",
+  description: "Clear the Linear activity log",
+  similes: ["clear-linear-activity", "reset-linear-activity", "delete-linear-activity"],
+  examples: [
+    [
+      {
+        name: "User",
+        content: {
+          text: "Clear the Linear activity log"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll clear the Linear activity log for you.",
+          actions: ["CLEAR_LINEAR_ACTIVITY"]
+        }
       }
-      this.logActivity("update_issue", "issue", issueId, updates, true);
-      return issue;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      this.logActivity("update_issue", "issue", issueId, updates, false, errorMessage);
-      throw new LinearAPIError(`Failed to update issue: ${errorMessage}`);
-    }
-  }
-  async deleteIssue(issueId) {
-    try {
-      const archivePayload = await this.client.archiveIssue(issueId);
-      const success = await archivePayload.success;
-      if (!success) {
-        throw new Error("Failed to archive issue");
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "Reset Linear activity"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll reset the Linear activity log now.",
+          actions: ["CLEAR_LINEAR_ACTIVITY"]
+        }
       }
-      this.logActivity("delete_issue", "issue", issueId, { action: "archived" }, true);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      this.logActivity("delete_issue", "issue", issueId, { action: "archive_failed" }, false, errorMessage);
-      throw new LinearAPIError(`Failed to archive issue: ${errorMessage}`);
-    }
-  }
-  async searchIssues(filters) {
+    ]
+  ],
+  async validate(runtime, _message, _state) {
+    const apiKey = runtime.getSetting("LINEAR_API_KEY");
+    return !!apiKey;
+  },
+  async handler(runtime, message, _state, _options, callback) {
     try {
-      let filterObject = {};
-      if (filters.query) {
-        filterObject.or = [
-          { title: { containsIgnoreCase: filters.query } },
-          { description: { containsIgnoreCase: filters.query } }
-        ];
-      }
-      if (filters.team) {
-        const teams = await this.getTeams();
-        const team = teams.find(
-          (t) => t.key.toLowerCase() === filters.team?.toLowerCase() || t.name.toLowerCase() === filters.team?.toLowerCase()
-        );
-        if (team) {
-          filterObject.team = { id: { eq: team.id } };
-        }
-      }
-      if (filters.assignee && filters.assignee.length > 0) {
-        const users = await this.getUsers();
-        const assigneeIds = filters.assignee.map((assigneeName) => {
-          const user = users.find(
-            (u) => u.email === assigneeName || u.name.toLowerCase().includes(assigneeName.toLowerCase())
-          );
-          return user?.id;
-        }).filter(Boolean);
-        if (assigneeIds.length > 0) {
-          filterObject.assignee = { id: { in: assigneeIds } };
-        }
-      }
-      if (filters.priority && filters.priority.length > 0) {
-        filterObject.priority = { number: { in: filters.priority } };
-      }
-      if (filters.state && filters.state.length > 0) {
-        filterObject.state = {
-          name: { in: filters.state }
-        };
-      }
-      if (filters.label && filters.label.length > 0) {
-        filterObject.labels = {
-          some: {
-            name: { in: filters.label }
-          }
-        };
+      const linearService = runtime.getService("linear");
+      if (!linearService) {
+        throw new Error("Linear service not available");
       }
-      const query = this.client.issues({
-        first: filters.limit || 50,
-        filter: Object.keys(filterObject).length > 0 ? filterObject : void 0
-      });
-      const issues = await query;
-      const issueList = await issues.nodes;
-      this.logActivity("search_issues", "issue", "search", {
-        filters,
-        count: issueList.length
-      }, true);
-      return issueList;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      this.logActivity("search_issues", "issue", "search", filters, false, errorMessage);
-      throw new LinearAPIError(`Failed to search issues: ${errorMessage}`);
-    }
-  }
-  // Comment operations
-  async createComment(input) {
-    try {
-      const commentPayload = await this.client.createComment({
-        body: input.body,
-        issueId: input.issueId
-      });
-      const comment = await commentPayload.comment;
-      if (!comment) {
-        throw new Error("Failed to create comment");
-      }
-      this.logActivity("create_comment", "comment", comment.id, {
-        issueId: input.issueId,
-        bodyLength: input.body.length
-      }, true);
-      return comment;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      this.logActivity("create_comment", "comment", "new", input, false, errorMessage);
-      throw new LinearAPIError(`Failed to create comment: ${errorMessage}`);
-    }
-  }
-  // Project operations
-  async getProjects(teamId) {
-    try {
-      const query = this.client.projects({
-        first: 100
-      });
-      const projects = await query;
-      let projectList = await projects.nodes;
-      if (teamId) {
-        const filteredProjects = await Promise.all(
-          projectList.map(async (project) => {
-            const projectTeams = await project.teams();
-            const teamsList = await projectTeams.nodes;
-            const hasTeam = teamsList.some((team) => team.id === teamId);
-            return hasTeam ? project : null;
-          })
-        );
-        projectList = filteredProjects.filter(Boolean);
-      }
-      this.logActivity("list_projects", "project", "all", {
-        count: projectList.length,
-        teamId
-      }, true);
-      return projectList;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      this.logActivity("list_projects", "project", "all", { teamId }, false, errorMessage);
-      throw new LinearAPIError(`Failed to fetch projects: ${errorMessage}`);
-    }
-  }
-  async getProject(projectId) {
-    try {
-      const project = await this.client.project(projectId);
-      this.logActivity("get_project", "project", projectId, {
-        name: project.name
-      }, true);
-      return project;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      this.logActivity("get_project", "project", projectId, {}, false, errorMessage);
-      throw new LinearAPIError(`Failed to fetch project: ${errorMessage}`);
-    }
-  }
-  // User operations
-  async getUsers() {
-    try {
-      const users = await this.client.users();
-      const userList = await users.nodes;
-      this.logActivity("list_users", "user", "all", {
-        count: userList.length
-      }, true);
-      return userList;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      this.logActivity("list_users", "user", "all", {}, false, errorMessage);
-      throw new LinearAPIError(`Failed to fetch users: ${errorMessage}`);
-    }
-  }
-  async getCurrentUser() {
-    try {
-      const user = await this.client.viewer;
-      this.logActivity("get_current_user", "user", user.id, {
-        email: user.email,
-        name: user.name
-      }, true);
-      return user;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      this.logActivity("get_current_user", "user", "current", {}, false, errorMessage);
-      throw new LinearAPIError(`Failed to fetch current user: ${errorMessage}`);
-    }
-  }
-  // Label operations
-  async getLabels(teamId) {
-    try {
-      const query = this.client.issueLabels({
-        first: 100,
-        filter: teamId ? {
-          team: { id: { eq: teamId } }
-        } : void 0
+      await linearService.clearActivityLog();
+      const successMessage = "✅ Linear activity log has been cleared.";
+      await callback?.({
+        text: successMessage,
+        source: message.content.source
       });
-      const labels = await query;
-      const labelList = await labels.nodes;
-      this.logActivity("list_labels", "label", "all", {
-        count: labelList.length,
-        teamId
-      }, true);
-      return labelList;
+      return {
+        text: successMessage,
+        success: true
+      };
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      this.logActivity("list_labels", "label", "all", { teamId }, false, errorMessage);
-      throw new LinearAPIError(`Failed to fetch labels: ${errorMessage}`);
-    }
-  }
-  // Workflow state operations
-  async getWorkflowStates(teamId) {
-    try {
-      const states = await this.client.workflowStates({
-        filter: {
-          team: { id: { eq: teamId } }
-        }
+      logger.error("Failed to clear Linear activity:", error);
+      const errorMessage = `❌ Failed to clear Linear activity: ${error instanceof Error ? error.message : "Unknown error"}`;
+      await callback?.({
+        text: errorMessage,
+        source: message.content.source
       });
-      const stateList = await states.nodes;
-      this.logActivity("list_workflow_states", "team", teamId, {
-        count: stateList.length
-      }, true);
-      return stateList;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      this.logActivity("list_workflow_states", "team", teamId, {}, false, errorMessage);
-      throw new LinearAPIError(`Failed to fetch workflow states: ${errorMessage}`);
+      return {
+        text: errorMessage,
+        success: false
+      };
     }
   }
 };
-_LinearService.serviceType = "linear";
-var LinearService = _LinearService;
 
-// src/actions/createIssue.ts
+// src/actions/createComment.ts
 import {
-  ModelType,
-  logger as logger2
+  logger as logger2,
+  ModelType
 } from "@elizaos/core";
+
+// src/generated/prompts/typescript/prompts.ts
+var createCommentTemplate = `Extract comment details from the user's request to add a comment to a Linear issue.
+
+User request: "{{userMessage}}"
+
+The user might express this in various ways:
+- "Comment on ENG-123: This looks good"
+- "Tell ENG-123 that the fix is ready for testing"
+- "Add a note to the login bug saying we need more info"
+- "Reply to COM2-7: Thanks for the update"
+- "Let the payment issue know that it's blocked by API changes"
+
+Return ONLY a JSON object:
+{
+  "issueId": "Direct issue ID if explicitly mentioned (e.g., ENG-123)",
+  "issueDescription": "Description/keywords of the issue if no ID provided",
+  "commentBody": "The actual comment content to add",
+  "commentType": "note/reply/update/question/feedback (inferred from context)"
+}
+
+Extract the core message the user wants to convey as the comment body.`;
 var createIssueTemplate = `Given the user's request, extract the information needed to create a Linear issue.
 
 User request: "{{userMessage}}"
@@ -430,222 +115,44 @@ Extract and return ONLY a JSON object (no markdown formatting, no code blocks) w
 }
 
 Return only the JSON object, no other text.`;
-var createIssueAction = {
-  name: "CREATE_LINEAR_ISSUE",
-  description: "Create a new issue in Linear",
-  similes: ["create-linear-issue", "new-linear-issue", "add-linear-issue"],
-  examples: [[
-    {
-      name: "User",
-      content: {
-        text: "Create a new issue: Fix login button not working on mobile devices"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll create that issue for you in Linear.",
-        actions: ["CREATE_LINEAR_ISSUE"]
-      }
-    }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "Create a bug report for the ENG team: API returns 500 error when updating user profile"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll create a bug report for the engineering team right away.",
-        actions: ["CREATE_LINEAR_ISSUE"]
-      }
-    }
-  ]],
-  async validate(runtime, _message, _state) {
-    try {
-      const apiKey = runtime.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    } catch {
-      return false;
-    }
+var deleteIssueTemplate = `Given the user's request to delete/archive a Linear issue, extract the issue identifier.
+
+User request: "{{userMessage}}"
+
+Extract and return ONLY a JSON object (no markdown formatting, no code blocks) with:
+{
+  "issueId": "The issue identifier (e.g., ENG-123, COM2-7)"
+}
+
+Return only the JSON object, no other text.`;
+var getActivityTemplate = `Extract activity filter criteria from the user's request.
+
+User request: "{{userMessage}}"
+
+The user might ask for activity in various ways:
+- "Show me today's activity" → time range filter
+- "What issues were created?" → action type filter
+- "What did John do yesterday?" → user filter + time range
+- "Activity on ENG-123" → resource filter
+- "Recent comment activity" → action type + recency
+- "Failed operations this week" → success filter + time range
+
+Return ONLY a JSON object:
+{
+  "timeRange": {
+    "period": "today/yesterday/this-week/last-week/this-month",
+    "from": "ISO datetime if specific",
+    "to": "ISO datetime if specific"
   },
-  async handler(runtime, message, _state, _options, callback) {
-    try {
-      const linearService = runtime.getService("linear");
-      if (!linearService) {
-        throw new Error("Linear service not available");
-      }
-      const content = message.content.text;
-      if (!content) {
-        const errorMessage = "Please provide a description for the issue.";
-        await callback?.({
-          text: errorMessage,
-          source: message.content.source
-        });
-        return {
-          text: errorMessage,
-          success: false
-        };
-      }
-      const structuredData = _options?.issueData;
-      let issueData;
-      if (structuredData) {
-        issueData = structuredData;
-      } else {
-        const prompt = createIssueTemplate.replace("{{userMessage}}", content);
-        const response = await runtime.useModel(ModelType.TEXT_LARGE, {
-          prompt
-        });
-        if (!response) {
-          throw new Error("Failed to extract issue information");
-        }
-        try {
-          const cleanedResponse = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
-          const parsed = JSON.parse(cleanedResponse);
-          issueData = {
-            title: parsed.title || void 0,
-            description: parsed.description || void 0,
-            priority: parsed.priority ? Number(parsed.priority) : void 0
-          };
-          if (parsed.teamKey) {
-            const teams = await linearService.getTeams();
-            const team = teams.find(
-              (t) => t.key.toLowerCase() === parsed.teamKey.toLowerCase()
-            );
-            if (team) {
-              issueData.teamId = team.id;
-            }
-          }
-          if (parsed.assignee && parsed.assignee !== "") {
-            const cleanAssignee = parsed.assignee.replace(/^@/, "");
-            const users = await linearService.getUsers();
-            const user = users.find(
-              (u) => u.email === cleanAssignee || u.name.toLowerCase().includes(cleanAssignee.toLowerCase())
-            );
-            if (user) {
-              issueData.assigneeId = user.id;
-            }
-          }
-          if (parsed.labels && Array.isArray(parsed.labels) && parsed.labels.length > 0) {
-            const labels = await linearService.getLabels(issueData.teamId);
-            const labelIds = [];
-            for (const labelName of parsed.labels) {
-              if (labelName && labelName !== "") {
-                const label = labels.find(
-                  (l) => l.name.toLowerCase() === labelName.toLowerCase()
-                );
-                if (label) {
-                  labelIds.push(label.id);
-                }
-              }
-            }
-            if (labelIds.length > 0) {
-              issueData.labelIds = labelIds;
-            }
-          }
-          if (!issueData.teamId) {
-            const defaultTeamKey = runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
-            if (defaultTeamKey) {
-              const teams = await linearService.getTeams();
-              const defaultTeam = teams.find(
-                (t) => t.key.toLowerCase() === defaultTeamKey.toLowerCase()
-              );
-              if (defaultTeam) {
-                issueData.teamId = defaultTeam.id;
-                logger2.info(`Using configured default team: ${defaultTeam.name} (${defaultTeam.key})`);
-              } else {
-                logger2.warn(`Default team key ${defaultTeamKey} not found`);
-              }
-            }
-            if (!issueData.teamId) {
-              const teams = await linearService.getTeams();
-              if (teams.length > 0) {
-                issueData.teamId = teams[0].id;
-                logger2.warn(`No team specified, using first available team: ${teams[0].name}`);
-              }
-            }
-          }
-        } catch (parseError) {
-          logger2.error("Failed to parse LLM response:", parseError);
-          issueData = {
-            title: content.length > 100 ? content.substring(0, 100) + "..." : content,
-            description: content
-          };
-          const defaultTeamKey = runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
-          const teams = await linearService.getTeams();
-          if (defaultTeamKey) {
-            const defaultTeam = teams.find(
-              (t) => t.key.toLowerCase() === defaultTeamKey.toLowerCase()
-            );
-            if (defaultTeam) {
-              issueData.teamId = defaultTeam.id;
-              logger2.info(`Using configured default team for fallback: ${defaultTeam.name} (${defaultTeam.key})`);
-            }
-          }
-          if (!issueData.teamId && teams.length > 0) {
-            issueData.teamId = teams[0].id;
-            logger2.warn(`Using first available team for fallback: ${teams[0].name}`);
-          }
-        }
-      }
-      if (!issueData.title) {
-        const errorMessage = "Could not determine issue title. Please provide more details.";
-        await callback?.({
-          text: errorMessage,
-          source: message.content.source
-        });
-        return {
-          text: errorMessage,
-          success: false
-        };
-      }
-      if (!issueData.teamId) {
-        const errorMessage = "No Linear teams found. Please ensure at least one team exists in your Linear workspace.";
-        await callback?.({
-          text: errorMessage,
-          source: message.content.source
-        });
-        return {
-          text: errorMessage,
-          success: false
-        };
-      }
-      const issue = await linearService.createIssue(issueData);
-      const successMessage = `\u2705 Created Linear issue: ${issue.title} (${issue.identifier})
-
-View it at: ${issue.url}`;
-      await callback?.({
-        text: successMessage,
-        source: message.content.source
-      });
-      return {
-        text: `Created issue: ${issue.title} (${issue.identifier})`,
-        success: true,
-        data: {
-          issueId: issue.id,
-          identifier: issue.identifier,
-          url: issue.url
-        }
-      };
-    } catch (error) {
-      logger2.error("Failed to create issue:", error);
-      const errorMessage = `\u274C Failed to create issue: ${error instanceof Error ? error.message : "Unknown error"}`;
-      await callback?.({
-        text: errorMessage,
-        source: message.content.source
-      });
-      return {
-        text: errorMessage,
-        success: false
-      };
-    }
-  }
-};
+  "actionTypes": ["create_issue/update_issue/delete_issue/create_comment/search_issues/etc"],
+  "resourceTypes": ["issue/project/comment/team"],
+  "resourceId": "Specific resource ID if mentioned (e.g., ENG-123)",
+  "user": "User name or 'me' for current user",
+  "successFilter": "success/failed/all",
+  "limit": number (default 10)
+}
 
-// src/actions/getIssue.ts
-import { logger as logger3, ModelType as ModelType2 } from "@elizaos/core";
+Only include fields that are clearly mentioned.`;
 var getIssueTemplate = `Extract issue identification from the user's request.
 
 User request: "{{userMessage}}"
@@ -672,285 +179,95 @@ Return ONLY a JSON object:
 }
 
 Only include fields that are clearly mentioned or implied.`;
-var getIssueAction = {
-  name: "GET_LINEAR_ISSUE",
-  description: "Get details of a specific Linear issue",
-  similes: ["get-linear-issue", "show-linear-issue", "view-linear-issue", "check-linear-issue", "find-linear-issue"],
-  examples: [[
-    {
-      name: "User",
-      content: {
-        text: "Show me issue ENG-123"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll get the details for issue ENG-123.",
-        actions: ["GET_LINEAR_ISSUE"]
-      }
-    }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "What's the status of the login bug?"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "Let me find the login bug issue for you.",
-        actions: ["GET_LINEAR_ISSUE"]
-      }
-    }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "Show me the latest high priority issue assigned to Sarah"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll find the latest high priority issue assigned to Sarah.",
-        actions: ["GET_LINEAR_ISSUE"]
-      }
-    }
-  ]],
-  async validate(runtime, _message, _state) {
-    try {
-      const apiKey = runtime.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    } catch {
-      return false;
-    }
+var listProjectsTemplate = `Extract project filter criteria from the user's request.
+
+User request: "{{userMessage}}"
+
+The user might ask for projects in various ways:
+- "Show me all projects" → list all projects
+- "Active projects" → filter by state (active/planned/completed)
+- "Projects due this quarter" → filter by target date
+- "Which projects is Sarah managing?" → filter by lead/owner
+- "Projects with high priority issues" → filter by contained issue priority
+- "Projects for the engineering team" → filter by team
+- "Completed projects" → filter by state
+- "Projects starting next month" → filter by start date
+
+Return ONLY a JSON object:
+{
+  "teamFilter": "Team name or key if mentioned",
+  "stateFilter": "active/planned/completed/all",
+  "dateFilter": {
+    "type": "due/starting",
+    "period": "this-week/this-month/this-quarter/next-month/next-quarter",
+    "from": "ISO date if specific",
+    "to": "ISO date if specific"
   },
-  async handler(runtime, message, _state, _options, callback) {
-    try {
-      const linearService = runtime.getService("linear");
-      if (!linearService) {
-        throw new Error("Linear service not available");
-      }
-      const content = message.content.text;
-      if (!content) {
-        const errorMessage2 = "Please specify which issue you want to see.";
-        await callback?.({
-          text: errorMessage2,
-          source: message.content.source
-        });
-        return {
-          text: errorMessage2,
-          success: false
-        };
-      }
-      const prompt = getIssueTemplate.replace("{{userMessage}}", content);
-      const response = await runtime.useModel(ModelType2.TEXT_LARGE, {
-        prompt
-      });
-      if (!response) {
-        const issueMatch = content.match(/(\w+-\d+)/);
-        if (issueMatch) {
-          const issue = await linearService.getIssue(issueMatch[1]);
-          return await formatIssueResponse(issue, callback, message);
-        }
-        throw new Error("Could not understand issue reference");
-      }
-      try {
-        const parsed = JSON.parse(response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim());
-        if (parsed.directId) {
-          const issue = await linearService.getIssue(parsed.directId);
-          return await formatIssueResponse(issue, callback, message);
-        }
-        if (parsed.searchBy && Object.keys(parsed.searchBy).length > 0) {
-          const filters = {};
-          if (parsed.searchBy.title) {
-            filters.query = parsed.searchBy.title;
-          }
-          if (parsed.searchBy.assignee) {
-            filters.assignee = [parsed.searchBy.assignee];
-          }
-          if (parsed.searchBy.priority) {
-            const priorityMap = {
-              "urgent": 1,
-              "high": 2,
-              "normal": 3,
-              "low": 4,
-              "1": 1,
-              "2": 2,
-              "3": 3,
-              "4": 4
-            };
-            const priority = priorityMap[parsed.searchBy.priority.toLowerCase()];
-            if (priority) {
-              filters.priority = [priority];
-            }
-          }
-          if (parsed.searchBy.team) {
-            filters.team = parsed.searchBy.team;
-          }
-          if (parsed.searchBy.state) {
-            filters.state = [parsed.searchBy.state];
-          }
-          const defaultTeamKey = runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
-          if (defaultTeamKey && !filters.team) {
-            filters.team = defaultTeamKey;
-          }
-          const issues = await linearService.searchIssues({
-            ...filters,
-            limit: parsed.searchBy.recency ? 10 : 5
-          });
-          if (issues.length === 0) {
-            const noResultsMessage = "No issues found matching your criteria.";
-            await callback?.({
-              text: noResultsMessage,
-              source: message.content.source
-            });
-            return {
-              text: noResultsMessage,
-              success: false
-            };
-          }
-          if (parsed.searchBy.recency) {
-            issues.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-          }
-          if (parsed.searchBy.recency && issues.length > 0) {
-            return await formatIssueResponse(issues[0], callback, message);
-          }
-          if (issues.length === 1) {
-            return await formatIssueResponse(issues[0], callback, message);
-          }
-          const issueList = await Promise.all(issues.slice(0, 5).map(async (issue, index) => {
-            const state = await issue.state;
-            return `${index + 1}. ${issue.identifier}: ${issue.title} (${state?.name || "No state"})`;
-          }));
-          const clarifyMessage = `Found ${issues.length} issues matching your criteria:
-${issueList.join("\n")}
+  "leadFilter": "Project lead name if mentioned",
+  "showAll": true/false (true if user explicitly asks for "all")
+}
 
-Please specify which one you want to see by its ID.`;
-          await callback?.({
-            text: clarifyMessage,
-            source: message.content.source
-          });
-          return {
-            text: clarifyMessage,
-            success: true,
-            data: {
-              multipleResults: true,
-              issues: issues.slice(0, 5).map((i) => ({
-                id: i.id,
-                identifier: i.identifier,
-                title: i.title
-              }))
-            }
-          };
-        }
-      } catch (parseError) {
-        logger3.warn("Failed to parse LLM response, falling back to regex:", parseError);
-        const issueMatch = content.match(/(\w+-\d+)/);
-        if (issueMatch) {
-          const issue = await linearService.getIssue(issueMatch[1]);
-          return await formatIssueResponse(issue, callback, message);
-        }
-      }
-      const errorMessage = "Could not understand which issue you want to see. Please provide an issue ID (e.g., ENG-123) or describe it more specifically.";
-      await callback?.({
-        text: errorMessage,
-        source: message.content.source
-      });
-      return {
-        text: errorMessage,
-        success: false
-      };
-    } catch (error) {
-      logger3.error("Failed to get issue:", error);
-      const errorMessage = `\u274C Failed to get issue: ${error instanceof Error ? error.message : "Unknown error"}`;
-      await callback?.({
-        text: errorMessage,
-        source: message.content.source
-      });
-      return {
-        text: errorMessage,
-        success: false
-      };
-    }
-  }
-};
-async function formatIssueResponse(issue, callback, message) {
-  const assignee = await issue.assignee;
-  const state = await issue.state;
-  const team = await issue.team;
-  const labels = await issue.labels();
-  const project = await issue.project;
-  const issueDetails = {
-    id: issue.id,
-    identifier: issue.identifier,
-    title: issue.title,
-    description: issue.description,
-    priority: issue.priority,
-    priorityLabel: issue.priorityLabel,
-    url: issue.url,
-    createdAt: issue.createdAt,
-    updatedAt: issue.updatedAt,
-    dueDate: issue.dueDate,
-    estimate: issue.estimate,
-    assignee: assignee ? {
-      id: assignee.id,
-      name: assignee.name,
-      email: assignee.email
-    } : null,
-    state: state ? {
-      id: state.id,
-      name: state.name,
-      type: state.type,
-      color: state.color
-    } : null,
-    team: team ? {
-      id: team.id,
-      name: team.name,
-      key: team.key
-    } : null,
-    labels: labels.nodes.map((label) => ({
-      id: label.id,
-      name: label.name,
-      color: label.color
-    })),
-    project: project ? {
-      id: project.id,
-      name: project.name,
-      description: project.description
-    } : null
-  };
-  const priorityLabels = ["", "Urgent", "High", "Normal", "Low"];
-  const priority = priorityLabels[issue.priority || 0] || "No priority";
-  const labelText = issueDetails.labels.length > 0 ? `Labels: ${issueDetails.labels.map((l) => l.name).join(", ")}` : "";
-  const issueMessage = `\u{1F4CB} **${issue.identifier}: ${issue.title}**
-  
-Status: ${state?.name || "No status"}
-Priority: ${priority}
-Team: ${team?.name || "No team"}
-Assignee: ${assignee?.name || "Unassigned"}
-${issue.dueDate ? `Due: ${new Date(issue.dueDate).toLocaleDateString()}` : ""}
-${labelText}
-${project ? `Project: ${project.name}` : ""}
+Only include fields that are clearly mentioned.`;
+var listTeamsTemplate = `Extract team filter criteria from the user's request.
 
-${issue.description || "No description"}
+User request: "{{userMessage}}"
 
-View in Linear: ${issue.url}`;
-  await callback?.({
-    text: issueMessage,
-    source: message.content.source
-  });
-  return {
-    text: `Retrieved issue ${issue.identifier}: ${issue.title}`,
-    success: true,
-    data: { issue: issueDetails }
-  };
+The user might ask for teams in various ways:
+- "Show me all teams" → list all teams
+- "Engineering teams" → filter by teams with engineering in name/description
+- "List teams I'm part of" → filter by membership
+- "Which teams work on the mobile app?" → filter by description/focus
+- "Show me the ELIZA team details" → specific team lookup
+- "Active teams" → teams with recent activity
+- "Frontend and backend teams" → multiple team types
+
+Return ONLY a JSON object:
+{
+  "nameFilter": "Keywords to search in team names",
+  "specificTeam": "Specific team name or key if looking for one team",
+  "myTeams": true/false (true if user wants their teams),
+  "showAll": true/false (true if user explicitly asks for "all"),
+  "includeDetails": true/false (true if user wants detailed info)
+}
+
+Only include fields that are clearly mentioned.`;
+var searchIssuesTemplate = `Extract search criteria from the user's request for Linear issues.
+
+User request: "{{userMessage}}"
+
+The user might express searches in various ways:
+- "Show me what John is working on" → assignee filter
+- "Any blockers for the next release?" → priority/label filters
+- "Issues created this week" → date range filter
+- "My high priority bugs" → assignee (current user) + priority + label
+- "Unassigned tasks in the backend team" → no assignee + team filter
+- "What did Sarah close yesterday?" → assignee + state + date
+- "Bugs that are almost done" → label + state filter
+- "Show me the oldest open issues" → state + sort order
+
+Extract and return ONLY a JSON object:
+{
+  "query": "General search text for title/description",
+  "states": ["state names like In Progress, Done, Todo, Backlog"],
+  "assignees": ["assignee names or emails, or 'me' for current user"],
+  "priorities": ["urgent/high/normal/low or 1/2/3/4"],
+  "teams": ["team names or keys"],
+  "labels": ["label names"],
+  "hasAssignee": true/false (true = has assignee, false = unassigned),
+  "dateRange": {
+    "field": "created/updated/completed",
+    "period": "today/yesterday/this-week/last-week/this-month/last-month",
+    "from": "ISO date if specific date",
+    "to": "ISO date if specific date"
+  },
+  "sort": {
+    "field": "created/updated/priority",
+    "order": "asc/desc"
+  },
+  "limit": number (default 10)
 }
 
-// src/actions/updateIssue.ts
-import { logger as logger4, ModelType as ModelType3 } from "@elizaos/core";
+Only include fields that are clearly mentioned or implied. For "my" issues, set assignees to ["me"].`;
 var updateIssueTemplate = `Given the user's request to update a Linear issue, extract the information needed.
 
 User request: "{{userMessage}}"
@@ -970,60 +287,67 @@ Extract and return ONLY a JSON object (no markdown formatting, no code blocks) w
 }
 
 Only include fields that are being updated. Return only the JSON object, no other text.`;
-var updateIssueAction = {
-  name: "UPDATE_LINEAR_ISSUE",
-  description: "Update an existing Linear issue",
-  similes: ["update-linear-issue", "edit-linear-issue", "modify-linear-issue", "move-linear-issue", "change-linear-issue"],
-  examples: [[
-    {
-      name: "User",
-      content: {
-        text: 'Update issue ENG-123 title to "Fix login button on all devices"'
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll update the title of issue ENG-123 for you.",
-        actions: ["UPDATE_LINEAR_ISSUE"]
+
+// src/actions/createComment.ts
+var createCommentAction = {
+  name: "CREATE_LINEAR_COMMENT",
+  description: "Add a comment to a Linear issue",
+  similes: [
+    "create-linear-comment",
+    "add-linear-comment",
+    "comment-on-linear-issue",
+    "reply-to-linear-issue"
+  ],
+  examples: [
+    [
+      {
+        name: "User",
+        content: {
+          text: "Comment on ENG-123: This looks good to me"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll add your comment to issue ENG-123.",
+          actions: ["CREATE_LINEAR_COMMENT"]
+        }
       }
-    }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "Move issue COM2-7 to the ELIZA team"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll move issue COM2-7 to the ELIZA team.",
-        actions: ["UPDATE_LINEAR_ISSUE"]
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "Tell the login bug that we need more information from QA"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll add that comment to the login bug issue.",
+          actions: ["CREATE_LINEAR_COMMENT"]
+        }
       }
-    }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "Change the priority of BUG-456 to high and assign to john@example.com"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll change the priority of BUG-456 to high and assign it to john@example.com.",
-        actions: ["UPDATE_LINEAR_ISSUE"]
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "Reply to COM2-7: Thanks for the update, I'll look into it"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll add your reply to issue COM2-7.",
+          actions: ["CREATE_LINEAR_COMMENT"]
+        }
       }
-    }
-  ]],
+    ]
+  ],
   async validate(runtime, _message, _state) {
-    try {
-      const apiKey = runtime.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    } catch {
-      return false;
-    }
+    const apiKey = runtime.getSetting("LINEAR_API_KEY");
+    return !!apiKey;
   },
   async handler(runtime, message, _state, _options, callback) {
     try {
@@ -1033,7 +357,7 @@ var updateIssueAction = {
       }
       const content = message.content.text;
       if (!content) {
-        const errorMessage = "Please provide update instructions for the issue.";
+        const errorMessage = "Please provide a message with the issue and comment content.";
         await callback?.({
           text: errorMessage,
           source: message.content.source
@@ -1043,126 +367,312 @@ var updateIssueAction = {
           success: false
         };
       }
-      const prompt = updateIssueTemplate.replace("{{userMessage}}", content);
-      const response = await runtime.useModel(ModelType3.TEXT_LARGE, {
-        prompt
-      });
-      if (!response) {
-        throw new Error("Failed to extract update information");
-      }
       let issueId;
-      let updates = {};
-      try {
-        const cleanedResponse = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
-        const parsed = JSON.parse(cleanedResponse);
-        issueId = parsed.issueId;
-        if (!issueId) {
-          throw new Error("Issue ID not found in parsed response");
+      let commentBody;
+      const params = _options?.parameters;
+      if (params?.issueId && params?.body) {
+        issueId = params.issueId;
+        commentBody = params.body;
+      } else {
+        const prompt = createCommentTemplate.replace("{{userMessage}}", content);
+        const response = await runtime.useModel(ModelType.TEXT_LARGE, {
+          prompt
+        });
+        if (!response) {
+          const issueMatch = content.match(/(?:comment on|add.*comment.*to|reply to|tell)\s+(\w+-\d+):?\s*(.*)/i);
+          if (issueMatch) {
+            issueId = issueMatch[1];
+            commentBody = issueMatch[2].trim();
+          } else {
+            throw new Error("Could not understand comment request");
+          }
+        } else {
+          try {
+            const parsed = JSON.parse(response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim());
+            if (parsed.issueId) {
+              issueId = parsed.issueId;
+              commentBody = parsed.commentBody;
+            } else if (parsed.issueDescription) {
+              const filters = {
+                query: parsed.issueDescription,
+                limit: 5
+              };
+              const defaultTeamKey = runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
+              if (defaultTeamKey) {
+                filters.team = defaultTeamKey;
+              }
+              const issues = await linearService.searchIssues(filters);
+              if (issues.length === 0) {
+                const errorMessage = `No issues found matching "${parsed.issueDescription}". Please provide a specific issue ID.`;
+                await callback?.({
+                  text: errorMessage,
+                  source: message.content.source
+                });
+                return {
+                  text: errorMessage,
+                  success: false
+                };
+              }
+              if (issues.length === 1) {
+                issueId = issues[0].identifier;
+                commentBody = parsed.commentBody;
+              } else {
+                const issueList = await Promise.all(issues.map(async (issue2, index) => {
+                  const state = await issue2.state;
+                  return `${index + 1}. ${issue2.identifier}: ${issue2.title} (${state?.name || "No state"})`;
+                }));
+                const clarifyMessage = `Found multiple issues matching "${parsed.issueDescription}":
+${issueList.join(`
+`)}
+
+Please specify which issue to comment on by its ID.`;
+                await callback?.({
+                  text: clarifyMessage,
+                  source: message.content.source
+                });
+                return {
+                  text: clarifyMessage,
+                  success: false,
+                  data: {
+                    multipleMatches: true,
+                    issues: issues.map((i) => ({
+                      id: i.id,
+                      identifier: i.identifier,
+                      title: i.title
+                    })),
+                    pendingComment: parsed.commentBody
+                  }
+                };
+              }
+            } else {
+              throw new Error("No issue identifier or description found");
+            }
+            if (parsed.commentType && parsed.commentType !== "note") {
+              commentBody = `[${parsed.commentType.toUpperCase()}] ${commentBody}`;
+            }
+          } catch (parseError) {
+            logger2.warn("Failed to parse LLM response, falling back to regex:", parseError);
+            const issueMatch = content.match(/(?:comment on|add.*comment.*to|reply to|tell)\s+(\w+-\d+):?\s*(.*)/i);
+            if (!issueMatch) {
+              const errorMessage = 'Please specify the issue ID and comment content. Example: "Comment on ENG-123: This looks good"';
+              await callback?.({
+                text: errorMessage,
+                source: message.content.source
+              });
+              return {
+                text: errorMessage,
+                success: false
+              };
+            }
+            issueId = issueMatch[1];
+            commentBody = issueMatch[2].trim();
+          }
         }
-        if (parsed.updates?.title) {
-          updates.title = parsed.updates.title;
+      }
+      if (!commentBody || commentBody.length === 0) {
+        const errorMessage = "Please provide the comment content.";
+        await callback?.({
+          text: errorMessage,
+          source: message.content.source
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const issue = await linearService.getIssue(issueId);
+      const comment = await linearService.createComment({
+        issueId: issue.id,
+        body: commentBody
+      });
+      const successMessage = `✅ Comment added to issue ${issue.identifier}: "${commentBody}"`;
+      await callback?.({
+        text: successMessage,
+        source: message.content.source
+      });
+      return {
+        text: `Added comment to issue ${issue.identifier}`,
+        success: true,
+        data: {
+          commentId: comment.id,
+          issueId: issue.id,
+          issueIdentifier: issue.identifier,
+          commentBody,
+          createdAt: comment.createdAt instanceof Date ? comment.createdAt.toISOString() : comment.createdAt
         }
-        if (parsed.updates?.description) {
-          updates.description = parsed.updates.description;
+      };
+    } catch (error) {
+      logger2.error("Failed to create comment:", error);
+      const errorMessage = `❌ Failed to create comment: ${error instanceof Error ? error.message : "Unknown error"}`;
+      await callback?.({
+        text: errorMessage,
+        source: message.content.source
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+  }
+};
+
+// src/actions/createIssue.ts
+import {
+  logger as logger3,
+  ModelType as ModelType2
+} from "@elizaos/core";
+var createIssueAction = {
+  name: "CREATE_LINEAR_ISSUE",
+  description: "Create a new issue in Linear",
+  similes: ["create-linear-issue", "new-linear-issue", "add-linear-issue"],
+  examples: [
+    [
+      {
+        name: "User",
+        content: {
+          text: "Create a new issue: Fix login button not working on mobile devices"
         }
-        if (parsed.updates?.priority) {
-          updates.priority = Number(parsed.updates.priority);
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll create that issue for you in Linear.",
+          actions: ["CREATE_LINEAR_ISSUE"]
         }
-        if (parsed.updates?.teamKey) {
-          const teams = await linearService.getTeams();
-          const team = teams.find(
-            (t) => t.key.toLowerCase() === parsed.updates.teamKey.toLowerCase()
-          );
-          if (team) {
-            updates.teamId = team.id;
-            logger4.info(`Moving issue to team: ${team.name} (${team.key})`);
-          } else {
-            logger4.warn(`Team with key ${parsed.updates.teamKey} not found`);
-          }
+      }
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "Create a bug report for the ENG team: API returns 500 error when updating user profile"
         }
-        if (parsed.updates?.assignee) {
-          const cleanAssignee = parsed.updates.assignee.replace(/^@/, "");
-          const users = await linearService.getUsers();
-          const user = users.find(
-            (u) => u.email === cleanAssignee || u.name.toLowerCase().includes(cleanAssignee.toLowerCase())
-          );
-          if (user) {
-            updates.assigneeId = user.id;
-          } else {
-            logger4.warn(`User ${cleanAssignee} not found`);
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll create a bug report for the engineering team right away.",
+          actions: ["CREATE_LINEAR_ISSUE"]
+        }
+      }
+    ]
+  ],
+  async validate(runtime, _message, _state) {
+    const apiKey = runtime.getSetting("LINEAR_API_KEY");
+    return !!apiKey;
+  },
+  async handler(runtime, message, _state, _options, callback) {
+    try {
+      const linearService = runtime.getService("linear");
+      if (!linearService) {
+        throw new Error("Linear service not available");
+      }
+      const content = message.content.text;
+      if (!content) {
+        const errorMessage = "Please provide a description for the issue.";
+        await callback?.({
+          text: errorMessage,
+          source: message.content.source
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const params = _options?.parameters;
+      const structuredData = params?.issueData;
+      let issueData;
+      if (structuredData) {
+        issueData = structuredData;
+      } else {
+        const prompt = createIssueTemplate.replace("{{userMessage}}", content);
+        const response = await runtime.useModel(ModelType2.TEXT_LARGE, {
+          prompt
+        });
+        if (!response) {
+          throw new Error("Failed to extract issue information");
+        }
+        try {
+          const cleanedResponse = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
+          const parsed = JSON.parse(cleanedResponse);
+          issueData = {
+            title: parsed.title || undefined,
+            description: parsed.description || undefined,
+            priority: parsed.priority ? Number(parsed.priority) : undefined
+          };
+          if (parsed.teamKey) {
+            const teams = await linearService.getTeams();
+            const team = teams.find((t) => t.key.toLowerCase() === parsed.teamKey.toLowerCase());
+            if (team) {
+              issueData.teamId = team.id;
+            }
           }
-        }
-        if (parsed.updates?.status) {
-          const issue = await linearService.getIssue(issueId);
-          const issueTeam = await issue.team;
-          const teamId = updates.teamId || issueTeam?.id;
-          if (!teamId) {
-            logger4.warn("Could not determine team for status update");
-          } else {
-            const states = await linearService.getWorkflowStates(teamId);
-            const state = states.find(
-              (s) => s.name.toLowerCase() === parsed.updates.status.toLowerCase() || s.type.toLowerCase() === parsed.updates.status.toLowerCase()
-            );
-            if (state) {
-              updates.stateId = state.id;
-              logger4.info(`Changing status to: ${state.name}`);
-            } else {
-              logger4.warn(`Status ${parsed.updates.status} not found for team`);
+          if (parsed.assignee && parsed.assignee !== "") {
+            const cleanAssignee = parsed.assignee.replace(/^@/, "");
+            const users = await linearService.getUsers();
+            const user = users.find((u) => u.email === cleanAssignee || u.name.toLowerCase().includes(cleanAssignee.toLowerCase()));
+            if (user) {
+              issueData.assigneeId = user.id;
             }
           }
-        }
-        if (parsed.updates?.labels && Array.isArray(parsed.updates.labels)) {
-          const teamId = updates.teamId;
-          const labels = await linearService.getLabels(teamId);
-          const labelIds = [];
-          for (const labelName of parsed.updates.labels) {
-            if (labelName) {
-              const label = labels.find(
-                (l) => l.name.toLowerCase() === labelName.toLowerCase()
-              );
-              if (label) {
-                labelIds.push(label.id);
+          if (parsed.labels && Array.isArray(parsed.labels) && parsed.labels.length > 0) {
+            const labels = await linearService.getLabels(issueData.teamId);
+            const labelIds = [];
+            for (const labelName of parsed.labels) {
+              if (labelName && labelName !== "") {
+                const label = labels.find((l) => l.name.toLowerCase() === labelName.toLowerCase());
+                if (label) {
+                  labelIds.push(label.id);
+                }
               }
             }
+            if (labelIds.length > 0) {
+              issueData.labelIds = labelIds;
+            }
           }
-          updates.labelIds = labelIds;
-        }
-      } catch (parseError) {
-        logger4.warn("Failed to parse LLM response, falling back to regex parsing:", parseError);
-        const issueMatch = content.match(/(\w+-\d+)/);
-        if (!issueMatch) {
-          const errorMessage = "Please specify an issue ID (e.g., ENG-123) to update.";
-          await callback?.({
-            text: errorMessage,
-            source: message.content.source
-          });
-          return {
-            text: errorMessage,
-            success: false
-          };
-        }
-        issueId = issueMatch[1];
-        const titleMatch = content.match(/title to ["'](.+?)["']/i);
-        if (titleMatch) {
-          updates.title = titleMatch[1];
-        }
-        const priorityMatch = content.match(/priority (?:to |as )?(\w+)/i);
-        if (priorityMatch) {
-          const priorityMap = {
-            "urgent": 1,
-            "high": 2,
-            "normal": 3,
-            "medium": 3,
-            "low": 4
+          if (!issueData.teamId) {
+            const defaultTeamKey = runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
+            if (defaultTeamKey) {
+              const teams = await linearService.getTeams();
+              const defaultTeam = teams.find((t) => t.key.toLowerCase() === defaultTeamKey.toLowerCase());
+              if (defaultTeam) {
+                issueData.teamId = defaultTeam.id;
+                logger3.info(`Using configured default team: ${defaultTeam.name} (${defaultTeam.key})`);
+              } else {
+                logger3.warn(`Default team key ${defaultTeamKey} not found`);
+              }
+            }
+            if (!issueData.teamId) {
+              const teams = await linearService.getTeams();
+              if (teams.length > 0) {
+                issueData.teamId = teams[0].id;
+                logger3.warn(`No team specified, using first available team: ${teams[0].name}`);
+              }
+            }
+          }
+        } catch (parseError) {
+          logger3.error("Failed to parse LLM response:", parseError);
+          issueData = {
+            title: content.length > 100 ? `${content.substring(0, 100)}...` : content,
+            description: content
           };
-          const priority = priorityMap[priorityMatch[1].toLowerCase()];
-          if (priority) {
-            updates.priority = priority;
+          const defaultTeamKey = runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
+          const teams = await linearService.getTeams();
+          if (defaultTeamKey) {
+            const defaultTeam = teams.find((t) => t.key.toLowerCase() === defaultTeamKey.toLowerCase());
+            if (defaultTeam) {
+              issueData.teamId = defaultTeam.id;
+              logger3.info(`Using configured default team for fallback: ${defaultTeam.name} (${defaultTeam.key})`);
+            }
+          }
+          if (!issueData.teamId && teams.length > 0) {
+            issueData.teamId = teams[0].id;
+            logger3.warn(`Using first available team for fallback: ${teams[0].name}`);
           }
         }
       }
-      if (Object.keys(updates).length === 0) {
-        const errorMessage = `No valid updates found. Please specify what to update (e.g., "Update issue ENG-123 title to 'New Title'")`;
+      if (!issueData.title) {
+        const errorMessage = "Could not determine issue title. Please provide more details.";
         await callback?.({
           text: errorMessage,
           source: message.content.source
@@ -1172,34 +682,37 @@ var updateIssueAction = {
           success: false
         };
       }
-      const updatedIssue = await linearService.updateIssue(issueId, updates);
-      const updateSummary = [];
-      if (updates.title) updateSummary.push(`title: "${updates.title}"`);
-      if (updates.priority) updateSummary.push(`priority: ${["", "urgent", "high", "normal", "low"][updates.priority]}`);
-      if (updates.teamId) updateSummary.push(`moved to team`);
-      if (updates.assigneeId) updateSummary.push(`assigned to user`);
-      if (updates.stateId) updateSummary.push(`status changed`);
-      if (updates.labelIds) updateSummary.push(`labels updated`);
-      const successMessage = `\u2705 Updated issue ${updatedIssue.identifier}: ${updateSummary.join(", ")}
+      if (!issueData.teamId) {
+        const errorMessage = "No Linear teams found. Please ensure at least one team exists in your Linear workspace.";
+        await callback?.({
+          text: errorMessage,
+          source: message.content.source
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const issue = await linearService.createIssue(issueData);
+      const successMessage = `✅ Created Linear issue: ${issue.title} (${issue.identifier})
 
-View it at: ${updatedIssue.url}`;
+View it at: ${issue.url}`;
       await callback?.({
         text: successMessage,
         source: message.content.source
       });
       return {
-        text: `Updated issue ${updatedIssue.identifier}: ${updateSummary.join(", ")}`,
+        text: `Created issue: ${issue.title} (${issue.identifier})`,
         success: true,
         data: {
-          issueId: updatedIssue.id,
-          identifier: updatedIssue.identifier,
-          updates,
-          url: updatedIssue.url
+          issueId: issue.id,
+          identifier: issue.identifier,
+          url: issue.url
         }
       };
     } catch (error) {
-      logger4.error("Failed to update issue:", error);
-      const errorMessage = `\u274C Failed to update issue: ${error instanceof Error ? error.message : "Unknown error"}`;
+      logger3.error("Failed to create issue:", error);
+      const errorMessage = `❌ Failed to create issue: ${error instanceof Error ? error.message : "Unknown error"}`;
       await callback?.({
         text: errorMessage,
         source: message.content.source
@@ -1213,71 +726,69 @@ View it at: ${updatedIssue.url}`;
 };
 
 // src/actions/deleteIssue.ts
-import { logger as logger5, ModelType as ModelType4 } from "@elizaos/core";
-var deleteIssueTemplate = `Given the user's request to delete/archive a Linear issue, extract the issue identifier.
-
-User request: "{{userMessage}}"
-
-Extract and return ONLY a JSON object (no markdown formatting, no code blocks) with:
-{
-  "issueId": "The issue identifier (e.g., ENG-123, COM2-7)"
-}
-
-Return only the JSON object, no other text.`;
+import {
+  logger as logger4,
+  ModelType as ModelType3
+} from "@elizaos/core";
 var deleteIssueAction = {
   name: "DELETE_LINEAR_ISSUE",
   description: "Delete (archive) an issue in Linear",
-  similes: ["delete-linear-issue", "archive-linear-issue", "remove-linear-issue", "close-linear-issue"],
-  examples: [[
-    {
-      name: "User",
-      content: {
-        text: "Delete issue ENG-123"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll archive issue ENG-123 for you.",
-        actions: ["DELETE_LINEAR_ISSUE"]
+  similes: [
+    "delete-linear-issue",
+    "archive-linear-issue",
+    "remove-linear-issue",
+    "close-linear-issue"
+  ],
+  examples: [
+    [
+      {
+        name: "User",
+        content: {
+          text: "Delete issue ENG-123"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll archive issue ENG-123 for you.",
+          actions: ["DELETE_LINEAR_ISSUE"]
+        }
       }
-    }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "Remove COM2-7 from Linear"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll archive issue COM2-7 in Linear.",
-        actions: ["DELETE_LINEAR_ISSUE"]
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "Remove COM2-7 from Linear"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll archive issue COM2-7 in Linear.",
+          actions: ["DELETE_LINEAR_ISSUE"]
+        }
       }
-    }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "Archive the bug report BUG-456"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll archive issue BUG-456 for you.",
-        actions: ["DELETE_LINEAR_ISSUE"]
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "Archive the bug report BUG-456"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll archive issue BUG-456 for you.",
+          actions: ["DELETE_LINEAR_ISSUE"]
+        }
       }
-    }
-  ]],
+    ]
+  ],
   async validate(runtime, _message, _state) {
-    try {
-      const apiKey = runtime.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    } catch {
-      return false;
-    }
+    const apiKey = runtime.getSetting("LINEAR_API_KEY");
+    return !!apiKey;
   },
   async handler(runtime, message, _state, _options, callback) {
     try {
@@ -1298,11 +809,12 @@ var deleteIssueAction = {
         };
       }
       let issueId;
-      if (_options?.issueId) {
-        issueId = _options.issueId;
+      const params = _options?.parameters;
+      if (params?.issueId) {
+        issueId = params.issueId;
       } else {
         const prompt = deleteIssueTemplate.replace("{{userMessage}}", content);
-        const response = await runtime.useModel(ModelType4.TEXT_LARGE, {
+        const response = await runtime.useModel(ModelType3.TEXT_LARGE, {
           prompt
         });
         if (!response) {
@@ -1316,7 +828,7 @@ var deleteIssueAction = {
             throw new Error("Issue ID not found in parsed response");
           }
         } catch (parseError) {
-          logger5.warn("Failed to parse LLM response, falling back to regex parsing:", parseError);
+          logger4.warn("Failed to parse LLM response, falling back to regex parsing:", parseError);
           const issueMatch = content.match(/(\w+-\d+)/);
           if (!issueMatch) {
             const errorMessage = "Please specify an issue ID (e.g., ENG-123) to delete.";
@@ -1335,9 +847,9 @@ var deleteIssueAction = {
       const issue = await linearService.getIssue(issueId);
       const issueTitle = issue.title;
       const issueIdentifier = issue.identifier;
-      logger5.info(`Archiving issue ${issueIdentifier}: ${issueTitle}`);
+      logger4.info(`Archiving issue ${issueIdentifier}: ${issueTitle}`);
       await linearService.deleteIssue(issueId);
-      const successMessage = `\u2705 Successfully archived issue ${issueIdentifier}: "${issueTitle}"
+      const successMessage = `✅ Successfully archived issue ${issueIdentifier}: "${issueTitle}"
 
 The issue has been moved to the archived state and will no longer appear in active views.`;
       await callback?.({
@@ -1355,8 +867,8 @@ The issue has been moved to the archived state and will no longer appear in acti
         }
       };
     } catch (error) {
-      logger5.error("Failed to delete issue:", error);
-      const errorMessage = `\u274C Failed to delete issue: ${error instanceof Error ? error.message : "Unknown error"}`;
+      logger4.error("Failed to delete issue:", error);
+      const errorMessage = `❌ Failed to delete issue: ${error instanceof Error ? error.message : "Unknown error"}`;
       await callback?.({
         text: errorMessage,
         source: message.content.source
@@ -1369,102 +881,70 @@ The issue has been moved to the archived state and will no longer appear in acti
   }
 };
 
-// src/actions/searchIssues.ts
+// src/actions/getActivity.ts
 import {
-  ModelType as ModelType5,
-  logger as logger6
+  logger as logger5,
+  ModelType as ModelType4
 } from "@elizaos/core";
-var searchTemplate = `Extract search criteria from the user's request for Linear issues.
-
-User request: "{{userMessage}}"
-
-The user might express searches in various ways:
-- "Show me what John is working on" \u2192 assignee filter
-- "Any blockers for the next release?" \u2192 priority/label filters
-- "Issues created this week" \u2192 date range filter
-- "My high priority bugs" \u2192 assignee (current user) + priority + label
-- "Unassigned tasks in the backend team" \u2192 no assignee + team filter
-- "What did Sarah close yesterday?" \u2192 assignee + state + date
-- "Bugs that are almost done" \u2192 label + state filter
-- "Show me the oldest open issues" \u2192 state + sort order
-
-Extract and return ONLY a JSON object:
-{
-  "query": "General search text for title/description",
-  "states": ["state names like In Progress, Done, Todo, Backlog"],
-  "assignees": ["assignee names or emails, or 'me' for current user"],
-  "priorities": ["urgent/high/normal/low or 1/2/3/4"],
-  "teams": ["team names or keys"],
-  "labels": ["label names"],
-  "hasAssignee": true/false (true = has assignee, false = unassigned),
-  "dateRange": {
-    "field": "created/updated/completed",
-    "period": "today/yesterday/this-week/last-week/this-month/last-month",
-    "from": "ISO date if specific date",
-    "to": "ISO date if specific date"
-  },
-  "sort": {
-    "field": "created/updated/priority",
-    "order": "asc/desc"
-  },
-  "limit": number (default 10)
-}
-
-Only include fields that are clearly mentioned or implied. For "my" issues, set assignees to ["me"].`;
-var searchIssuesAction = {
-  name: "SEARCH_LINEAR_ISSUES",
-  description: "Search for issues in Linear with various filters",
-  similes: ["search-linear-issues", "find-linear-issues", "query-linear-issues", "list-linear-issues"],
-  examples: [[
-    {
-      name: "User",
-      content: {
-        text: "Show me all open bugs"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll search for all open bug issues in Linear.",
-        actions: ["SEARCH_LINEAR_ISSUES"]
+var getActivityAction = {
+  name: "GET_LINEAR_ACTIVITY",
+  description: "Get recent Linear activity log with optional filters",
+  similes: [
+    "get-linear-activity",
+    "show-linear-activity",
+    "view-linear-activity",
+    "check-linear-activity"
+  ],
+  examples: [
+    [
+      {
+        name: "User",
+        content: {
+          text: "Show me recent Linear activity"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll show you the recent Linear activity.",
+          actions: ["GET_LINEAR_ACTIVITY"]
+        }
       }
-    }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "What is John working on?"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll find the issues assigned to John.",
-        actions: ["SEARCH_LINEAR_ISSUES"]
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "What happened in Linear today?"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "Let me check today's Linear activity for you.",
+          actions: ["GET_LINEAR_ACTIVITY"]
+        }
       }
-    }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "Show me high priority issues created this week"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll search for high priority issues created this week.",
-        actions: ["SEARCH_LINEAR_ISSUES"]
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "Show me what issues John created this week"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll find the issues John created this week.",
+          actions: ["GET_LINEAR_ACTIVITY"]
+        }
       }
-    }
-  ]],
+    ]
+  ],
   async validate(runtime, _message, _state) {
-    try {
-      const apiKey = runtime.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    } catch {
-      return false;
-    }
+    const apiKey = runtime.getSetting("LINEAR_API_KEY");
+    return !!apiKey;
   },
   async handler(runtime, message, _state, _options, callback) {
     try {
@@ -1472,168 +952,351 @@ var searchIssuesAction = {
       if (!linearService) {
         throw new Error("Linear service not available");
       }
-      const content = message.content.text;
-      if (!content) {
-        const errorMessage = "Please provide search criteria for issues.";
-        await callback?.({
-          text: errorMessage,
-          source: message.content.source
-        });
-        return {
-          text: errorMessage,
-          success: false
-        };
-      }
-      let filters = {};
-      if (_options?.filters) {
-        filters = _options.filters;
-      } else {
-        const prompt = searchTemplate.replace("{{userMessage}}", content);
-        const response = await runtime.useModel(ModelType5.TEXT_LARGE, {
+      const content = message.content.text || "";
+      const filters = {};
+      let limit = 10;
+      if (content) {
+        const prompt = getActivityTemplate.replace("{{userMessage}}", content);
+        const response = await runtime.useModel(ModelType4.TEXT_LARGE, {
           prompt
         });
-        if (!response) {
-          filters = { query: content };
-        } else {
+        if (response) {
           try {
-            const cleanedResponse = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
-            const parsed = JSON.parse(cleanedResponse);
-            filters = {
-              query: parsed.query,
-              limit: parsed.limit || 10
-            };
-            if (parsed.states && parsed.states.length > 0) {
-              filters.state = parsed.states;
-            }
-            if (parsed.assignees && parsed.assignees.length > 0) {
-              const processedAssignees = [];
-              for (const assignee of parsed.assignees) {
-                if (assignee.toLowerCase() === "me") {
-                  try {
-                    const currentUser = await linearService.getCurrentUser();
-                    processedAssignees.push(currentUser.email);
-                  } catch {
-                    logger6.warn('Could not resolve "me" to current user');
-                  }
-                } else {
-                  processedAssignees.push(assignee);
+            const parsed = JSON.parse(response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim());
+            if (parsed.timeRange) {
+              const now = new Date;
+              let fromDate;
+              if (parsed.timeRange.from) {
+                fromDate = new Date(parsed.timeRange.from);
+              } else if (parsed.timeRange.period) {
+                switch (parsed.timeRange.period) {
+                  case "today":
+                    fromDate = new Date(now.setHours(0, 0, 0, 0));
+                    break;
+                  case "yesterday":
+                    fromDate = new Date(now.setDate(now.getDate() - 1));
+                    fromDate.setHours(0, 0, 0, 0);
+                    break;
+                  case "this-week":
+                    fromDate = new Date(now.setDate(now.getDate() - now.getDay()));
+                    fromDate.setHours(0, 0, 0, 0);
+                    break;
+                  case "last-week":
+                    fromDate = new Date(now.setDate(now.getDate() - now.getDay() - 7));
+                    fromDate.setHours(0, 0, 0, 0);
+                    break;
+                  case "this-month":
+                    fromDate = new Date(now.getFullYear(), now.getMonth(), 1);
+                    break;
                 }
               }
-              if (processedAssignees.length > 0) {
-                filters.assignee = processedAssignees;
+              if (fromDate) {
+                filters.fromDate = fromDate.toISOString();
               }
             }
-            if (parsed.hasAssignee === false) {
-              filters.query = (filters.query ? filters.query + " " : "") + "unassigned";
-            }
-            if (parsed.priorities && parsed.priorities.length > 0) {
-              const priorityMap = {
-                "urgent": 1,
-                "high": 2,
-                "normal": 3,
-                "low": 4,
-                "1": 1,
-                "2": 2,
-                "3": 3,
-                "4": 4
-              };
-              const priorities = parsed.priorities.map((p) => priorityMap[p.toLowerCase()]).filter(Boolean);
-              if (priorities.length > 0) {
-                filters.priority = priorities;
-              }
+            if (parsed.actionTypes && parsed.actionTypes.length > 0) {
+              filters.action = parsed.actionTypes[0];
             }
-            if (parsed.teams && parsed.teams.length > 0) {
-              filters.team = parsed.teams[0];
+            if (parsed.resourceTypes && parsed.resourceTypes.length > 0) {
+              filters.resource_type = parsed.resourceTypes[0];
             }
-            if (parsed.labels && parsed.labels.length > 0) {
-              filters.label = parsed.labels;
+            if (parsed.resourceId) {
+              filters.resource_id = parsed.resourceId;
             }
-            if (parsed.dateRange || parsed.sort) {
-              logger6.info("Date range and sort filters noted but not yet implemented");
+            if (parsed.successFilter && parsed.successFilter !== "all") {
+              filters.success = parsed.successFilter === "success";
             }
-            Object.keys(filters).forEach((key) => {
-              if (filters[key] === void 0) {
-                delete filters[key];
-              }
-            });
+            limit = parsed.limit || 10;
           } catch (parseError) {
-            logger6.error("Failed to parse search filters:", parseError);
-            filters = { query: content };
+            logger5.warn("Failed to parse activity filters:", parseError);
           }
         }
       }
-      if (!filters.team) {
-        const defaultTeamKey = runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
-        if (defaultTeamKey) {
-          const searchingAllIssues = content.toLowerCase().includes("all") && (content.toLowerCase().includes("issue") || content.toLowerCase().includes("bug") || content.toLowerCase().includes("task"));
-          if (!searchingAllIssues) {
-            filters.team = defaultTeamKey;
-            logger6.info(`Applying default team filter: ${defaultTeamKey}`);
-          }
+      let activity = linearService.getActivityLog(limit * 2, filters);
+      if (filters.fromDate) {
+        const fromDateValue = filters.fromDate;
+        const fromDate = typeof fromDateValue === "string" ? fromDateValue : fromDateValue instanceof Date ? fromDateValue.toISOString() : String(fromDateValue);
+        const fromTime = new Date(fromDate).getTime();
+        if (!Number.isNaN(fromTime)) {
+          activity = activity.filter((item) => new Date(item.timestamp).getTime() >= fromTime);
         }
       }
-      filters.limit = _options?.limit || filters.limit || 10;
-      const issues = await linearService.searchIssues(filters);
-      if (issues.length === 0) {
-        const noResultsMessage = "No issues found matching your search criteria.";
+      activity = activity.slice(0, limit);
+      if (activity.length === 0) {
+        const noActivityMessage = filters.fromDate ? `No Linear activity found for the specified filters.` : "No recent Linear activity found.";
         await callback?.({
-          text: noResultsMessage,
+          text: noActivityMessage,
           source: message.content.source
         });
         return {
-          text: noResultsMessage,
+          text: noActivityMessage,
           success: true,
           data: {
-            issues: [],
-            filters,
-            count: 0
+            activity: []
           }
         };
       }
-      const issueList = await Promise.all(issues.map(async (issue, index) => {
-        const state = await issue.state;
-        const assignee = await issue.assignee;
-        const priorityLabels = ["", "Urgent", "High", "Normal", "Low"];
-        const priority = priorityLabels[issue.priority || 0] || "No priority";
-        return `${index + 1}. ${issue.identifier}: ${issue.title}
-   Status: ${state?.name || "No state"} | Priority: ${priority} | Assignee: ${assignee?.name || "Unassigned"}`;
-      }));
-      const issueText = issueList.join("\n\n");
-      const resultMessage = `\u{1F4CB} Found ${issues.length} issue${issues.length === 1 ? "" : "s"}:
+      const activityText = activity.map((item, index) => {
+        const time = new Date(item.timestamp).toLocaleString();
+        const status = item.success ? "✅" : "❌";
+        const details = Object.entries(item.details).filter(([key]) => key !== "filters").map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(", ");
+        return `${index + 1}. ${status} ${item.action} on ${item.resource_type} ${item.resource_id}
+   Time: ${time}
+   ${details ? `Details: ${details}` : ""}${item.error ? `
+   Error: ${item.error}` : ""}`;
+      }).join(`
 
-${issueText}`;
+`);
+      const headerText = filters.fromDate ? `\uD83D\uDCCA Linear activity ${content}:` : "\uD83D\uDCCA Recent Linear activity:";
+      const resultMessage = `${headerText}
+
+${activityText}`;
       await callback?.({
         text: resultMessage,
         source: message.content.source
       });
       return {
-        text: `Found ${issues.length} issue${issues.length === 1 ? "" : "s"}`,
+        text: `Found ${activity.length} activity item${activity.length === 1 ? "" : "s"}`,
         success: true,
         data: {
-          issues: await Promise.all(issues.map(async (issue) => {
-            const state = await issue.state;
-            const assignee = await issue.assignee;
-            const team = await issue.team;
+          activity: activity.map((item) => ({
+            id: item.id,
+            action: item.action,
+            resource_type: item.resource_type,
+            resource_id: item.resource_id,
+            success: item.success,
+            error: item.error,
+            details: JSON.stringify(item.details),
+            timestamp: typeof item.timestamp === "string" ? item.timestamp : new Date(item.timestamp).toISOString()
+          })),
+          filters: filters ? {
+            ...filters,
+            fromDate: filters.fromDate ? typeof filters.fromDate === "string" ? filters.fromDate : String(filters.fromDate) : undefined
+          } : undefined,
+          count: activity.length
+        }
+      };
+    } catch (error) {
+      logger5.error("Failed to get activity:", error);
+      const errorMessage = `❌ Failed to get activity: ${error instanceof Error ? error.message : "Unknown error"}`;
+      await callback?.({
+        text: errorMessage,
+        source: message.content.source
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+  }
+};
+
+// src/actions/getIssue.ts
+import {
+  logger as logger6,
+  ModelType as ModelType5
+} from "@elizaos/core";
+var getIssueAction = {
+  name: "GET_LINEAR_ISSUE",
+  description: "Get details of a specific Linear issue",
+  similes: [
+    "get-linear-issue",
+    "show-linear-issue",
+    "view-linear-issue",
+    "check-linear-issue",
+    "find-linear-issue"
+  ],
+  examples: [
+    [
+      {
+        name: "User",
+        content: {
+          text: "Show me issue ENG-123"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll get the details for issue ENG-123.",
+          actions: ["GET_LINEAR_ISSUE"]
+        }
+      }
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "What's the status of the login bug?"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "Let me find the login bug issue for you.",
+          actions: ["GET_LINEAR_ISSUE"]
+        }
+      }
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "Show me the latest high priority issue assigned to Sarah"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll find the latest high priority issue assigned to Sarah.",
+          actions: ["GET_LINEAR_ISSUE"]
+        }
+      }
+    ]
+  ],
+  async validate(runtime, _message, _state) {
+    const apiKey = runtime.getSetting("LINEAR_API_KEY");
+    return !!apiKey;
+  },
+  async handler(runtime, message, _state, _options, callback) {
+    try {
+      const linearService = runtime.getService("linear");
+      if (!linearService) {
+        throw new Error("Linear service not available");
+      }
+      const content = message.content.text;
+      if (!content) {
+        const errorMessage2 = "Please specify which issue you want to see.";
+        await callback?.({
+          text: errorMessage2,
+          source: message.content.source
+        });
+        return {
+          text: errorMessage2,
+          success: false
+        };
+      }
+      const prompt = getIssueTemplate.replace("{{userMessage}}", content);
+      const response = await runtime.useModel(ModelType5.TEXT_LARGE, {
+        prompt
+      });
+      if (!response) {
+        const issueMatch = content.match(/(\w+-\d+)/);
+        if (issueMatch) {
+          const issue = await linearService.getIssue(issueMatch[1]);
+          return await formatIssueResponse(issue, callback, message);
+        }
+        throw new Error("Could not understand issue reference");
+      }
+      try {
+        const parsed = JSON.parse(response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim());
+        if (parsed.directId) {
+          const issue = await linearService.getIssue(parsed.directId);
+          return await formatIssueResponse(issue, callback, message);
+        }
+        if (parsed.searchBy && Object.keys(parsed.searchBy).length > 0) {
+          const filters = {};
+          if (parsed.searchBy.title) {
+            filters.query = parsed.searchBy.title;
+          }
+          if (parsed.searchBy.assignee) {
+            filters.assignee = [parsed.searchBy.assignee];
+          }
+          if (parsed.searchBy.priority) {
+            const priorityMap = {
+              urgent: 1,
+              high: 2,
+              normal: 3,
+              low: 4,
+              "1": 1,
+              "2": 2,
+              "3": 3,
+              "4": 4
+            };
+            const priority = priorityMap[parsed.searchBy.priority.toLowerCase()];
+            if (priority) {
+              filters.priority = [priority];
+            }
+          }
+          if (parsed.searchBy.team) {
+            filters.team = parsed.searchBy.team;
+          }
+          if (parsed.searchBy.state) {
+            filters.state = [parsed.searchBy.state];
+          }
+          const defaultTeamKey = runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
+          if (defaultTeamKey && !filters.team) {
+            filters.team = defaultTeamKey;
+          }
+          const issues = await linearService.searchIssues({
+            ...filters,
+            limit: parsed.searchBy.recency ? 10 : 5
+          });
+          if (issues.length === 0) {
+            const noResultsMessage = "No issues found matching your criteria.";
+            await callback?.({
+              text: noResultsMessage,
+              source: message.content.source
+            });
             return {
-              id: issue.id,
-              identifier: issue.identifier,
-              title: issue.title,
-              url: issue.url,
-              priority: issue.priority,
-              state: state ? { name: state.name, type: state.type } : null,
-              assignee: assignee ? { name: assignee.name, email: assignee.email } : null,
-              team: team ? { name: team.name, key: team.key } : null,
-              createdAt: issue.createdAt,
-              updatedAt: issue.updatedAt
+              text: noResultsMessage,
+              success: false
             };
-          })),
-          filters,
-          count: issues.length
+          }
+          if (parsed.searchBy.recency) {
+            issues.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+          }
+          if (parsed.searchBy.recency && issues.length > 0) {
+            return await formatIssueResponse(issues[0], callback, message);
+          }
+          if (issues.length === 1) {
+            return await formatIssueResponse(issues[0], callback, message);
+          }
+          const issueList = await Promise.all(issues.slice(0, 5).map(async (issue, index) => {
+            const state = await issue.state;
+            return `${index + 1}. ${issue.identifier}: ${issue.title} (${state?.name || "No state"})`;
+          }));
+          const clarifyMessage = `Found ${issues.length} issues matching your criteria:
+${issueList.join(`
+`)}
+
+Please specify which one you want to see by its ID.`;
+          await callback?.({
+            text: clarifyMessage,
+            source: message.content.source
+          });
+          return {
+            text: clarifyMessage,
+            success: true,
+            data: {
+              multipleResults: true,
+              issues: issues.slice(0, 5).map((i) => ({
+                id: i.id,
+                identifier: i.identifier,
+                title: i.title
+              }))
+            }
+          };
+        }
+      } catch (parseError) {
+        logger6.warn("Failed to parse LLM response, falling back to regex:", parseError);
+        const issueMatch = content.match(/(\w+-\d+)/);
+        if (issueMatch) {
+          const issue = await linearService.getIssue(issueMatch[1]);
+          return await formatIssueResponse(issue, callback, message);
         }
+      }
+      const errorMessage = "Could not understand which issue you want to see. Please provide an issue ID (e.g., ENG-123) or describe it more specifically.";
+      await callback?.({
+        text: errorMessage,
+        source: message.content.source
+      });
+      return {
+        text: errorMessage,
+        success: false
       };
     } catch (error) {
-      logger6.error("Failed to search issues:", error);
-      const errorMessage = `\u274C Failed to search issues: ${error instanceof Error ? error.message : "Unknown error"}`;
+      logger6.error("Failed to get issue:", error);
+      const errorMessage = `❌ Failed to get issue: ${error instanceof Error ? error.message : "Unknown error"}`;
       await callback?.({
         text: errorMessage,
         source: message.content.source
@@ -1645,83 +1308,148 @@ ${issueText}`;
     }
   }
 };
+async function formatIssueResponse(issue, callback, message) {
+  const assignee = await issue.assignee;
+  const state = await issue.state;
+  const team = await issue.team;
+  const labels = await issue.labels();
+  const project = await issue.project;
+  const issueDetails = {
+    id: issue.id,
+    identifier: issue.identifier,
+    title: issue.title,
+    description: issue.description,
+    priority: issue.priority,
+    priorityLabel: issue.priorityLabel,
+    url: issue.url,
+    createdAt: issue.createdAt,
+    updatedAt: issue.updatedAt,
+    dueDate: issue.dueDate,
+    estimate: issue.estimate,
+    assignee: assignee ? {
+      id: assignee.id,
+      name: assignee.name,
+      email: assignee.email
+    } : null,
+    state: state ? {
+      id: state.id,
+      name: state.name,
+      type: state.type,
+      color: state.color
+    } : null,
+    team: team ? {
+      id: team.id,
+      name: team.name,
+      key: team.key
+    } : null,
+    labels: labels.nodes.map((label) => ({
+      id: label.id,
+      name: label.name,
+      color: label.color
+    })),
+    project: project ? {
+      id: project.id,
+      name: project.name,
+      description: project.description
+    } : null
+  };
+  const priorityLabels = ["", "Urgent", "High", "Normal", "Low"];
+  const priority = priorityLabels[issue.priority || 0] || "No priority";
+  const labelText = issueDetails.labels.length > 0 ? `Labels: ${issueDetails.labels.map((l) => l.name).join(", ")}` : "";
+  const issueMessage = `\uD83D\uDCCB **${issue.identifier}: ${issue.title}**
+  
+Status: ${state?.name || "No status"}
+Priority: ${priority}
+Team: ${team?.name || "No team"}
+Assignee: ${assignee?.name || "Unassigned"}
+${issue.dueDate ? `Due: ${new Date(issue.dueDate).toLocaleDateString()}` : ""}
+${labelText}
+${project ? `Project: ${project.name}` : ""}
 
-// src/actions/createComment.ts
-import { logger as logger7, ModelType as ModelType6 } from "@elizaos/core";
-var createCommentTemplate = `Extract comment details from the user's request to add a comment to a Linear issue.
-
-User request: "{{userMessage}}"
-
-The user might express this in various ways:
-- "Comment on ENG-123: This looks good"
-- "Tell ENG-123 that the fix is ready for testing"
-- "Add a note to the login bug saying we need more info"
-- "Reply to COM2-7: Thanks for the update"
-- "Let the payment issue know that it's blocked by API changes"
+${issue.description || "No description"}
 
-Return ONLY a JSON object:
-{
-  "issueId": "Direct issue ID if explicitly mentioned (e.g., ENG-123)",
-  "issueDescription": "Description/keywords of the issue if no ID provided",
-  "commentBody": "The actual comment content to add",
-  "commentType": "note/reply/update/question/feedback (inferred from context)"
+View in Linear: ${issue.url}`;
+  await callback?.({
+    text: issueMessage,
+    source: message.content.source
+  });
+  const serializedIssue = {
+    ...issueDetails,
+    createdAt: issueDetails.createdAt instanceof Date ? issueDetails.createdAt.toISOString() : issueDetails.createdAt,
+    updatedAt: issueDetails.updatedAt instanceof Date ? issueDetails.updatedAt.toISOString() : issueDetails.updatedAt,
+    dueDate: issueDetails.dueDate ? issueDetails.dueDate instanceof Date ? issueDetails.dueDate.toISOString() : issueDetails.dueDate : null
+  };
+  return {
+    text: `Retrieved issue ${issue.identifier}: ${issue.title}`,
+    success: true,
+    data: { issue: serializedIssue }
+  };
 }
 
-Extract the core message the user wants to convey as the comment body.`;
-var createCommentAction = {
-  name: "CREATE_LINEAR_COMMENT",
-  description: "Add a comment to a Linear issue",
-  similes: ["create-linear-comment", "add-linear-comment", "comment-on-linear-issue", "reply-to-linear-issue"],
-  examples: [[
-    {
-      name: "User",
-      content: {
-        text: "Comment on ENG-123: This looks good to me"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll add your comment to issue ENG-123.",
-        actions: ["CREATE_LINEAR_COMMENT"]
+// src/actions/listProjects.ts
+import {
+  logger as logger7,
+  ModelType as ModelType6
+} from "@elizaos/core";
+var listProjectsAction = {
+  name: "LIST_LINEAR_PROJECTS",
+  description: "List projects in Linear with optional filters",
+  similes: [
+    "list-linear-projects",
+    "show-linear-projects",
+    "get-linear-projects",
+    "view-linear-projects"
+  ],
+  examples: [
+    [
+      {
+        name: "User",
+        content: {
+          text: "Show me all projects"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll list all the projects in Linear for you.",
+          actions: ["LIST_LINEAR_PROJECTS"]
+        }
       }
-    }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "Tell the login bug that we need more information from QA"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll add that comment to the login bug issue.",
-        actions: ["CREATE_LINEAR_COMMENT"]
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "What active projects do we have?"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "Let me show you all the active projects.",
+          actions: ["LIST_LINEAR_PROJECTS"]
+        }
       }
-    }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "Reply to COM2-7: Thanks for the update, I'll look into it"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll add your reply to issue COM2-7.",
-        actions: ["CREATE_LINEAR_COMMENT"]
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "Show me projects for the engineering team"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll find the projects for the engineering team.",
+          actions: ["LIST_LINEAR_PROJECTS"]
+        }
       }
-    }
-  ]],
+    ]
+  ],
   async validate(runtime, _message, _state) {
-    try {
-      const apiKey = runtime.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    } catch {
-      return false;
-    }
+    const apiKey = runtime.getSetting("LINEAR_API_KEY");
+    return !!apiKey;
   },
   async handler(runtime, message, _state, _options, callback) {
     try {
@@ -1729,153 +1457,151 @@ var createCommentAction = {
       if (!linearService) {
         throw new Error("Linear service not available");
       }
-      const content = message.content.text;
-      if (!content) {
-        const errorMessage = "Please provide a message with the issue and comment content.";
-        await callback?.({
-          text: errorMessage,
-          source: message.content.source
-        });
-        return {
-          text: errorMessage,
-          success: false
-        };
-      }
-      let issueId;
-      let commentBody;
-      if (_options?.issueId && _options?.body) {
-        issueId = _options.issueId;
-        commentBody = _options.body;
-      } else {
-        const prompt = createCommentTemplate.replace("{{userMessage}}", content);
+      const content = message.content.text || "";
+      let teamId;
+      let showAll = false;
+      let stateFilter;
+      if (content) {
+        const prompt = listProjectsTemplate.replace("{{userMessage}}", content);
         const response = await runtime.useModel(ModelType6.TEXT_LARGE, {
           prompt
         });
-        if (!response) {
-          const issueMatch = content.match(/(?:comment on|add.*comment.*to|reply to|tell)\s+(\w+-\d+):?\s*(.*)/i);
-          if (issueMatch) {
-            issueId = issueMatch[1];
-            commentBody = issueMatch[2].trim();
-          } else {
-            throw new Error("Could not understand comment request");
-          }
-        } else {
+        if (response) {
           try {
             const parsed = JSON.parse(response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim());
-            if (parsed.issueId) {
-              issueId = parsed.issueId;
-              commentBody = parsed.commentBody;
-            } else if (parsed.issueDescription) {
-              const filters = {
-                query: parsed.issueDescription,
-                limit: 5
-              };
-              const defaultTeamKey = runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
-              if (defaultTeamKey) {
-                filters.team = defaultTeamKey;
-              }
-              const issues = await linearService.searchIssues(filters);
-              if (issues.length === 0) {
-                const errorMessage = `No issues found matching "${parsed.issueDescription}". Please provide a specific issue ID.`;
-                await callback?.({
-                  text: errorMessage,
-                  source: message.content.source
-                });
-                return {
-                  text: errorMessage,
-                  success: false
-                };
-              }
-              if (issues.length === 1) {
-                issueId = issues[0].identifier;
-                commentBody = parsed.commentBody;
-              } else {
-                const issueList = await Promise.all(issues.map(async (issue2, index) => {
-                  const state = await issue2.state;
-                  return `${index + 1}. ${issue2.identifier}: ${issue2.title} (${state?.name || "No state"})`;
-                }));
-                const clarifyMessage = `Found multiple issues matching "${parsed.issueDescription}":
-${issueList.join("\n")}
-
-Please specify which issue to comment on by its ID.`;
-                await callback?.({
-                  text: clarifyMessage,
-                  source: message.content.source
-                });
-                return {
-                  text: clarifyMessage,
-                  success: false,
-                  data: {
-                    multipleMatches: true,
-                    issues: issues.map((i) => ({
-                      id: i.id,
-                      identifier: i.identifier,
-                      title: i.title
-                    })),
-                    pendingComment: parsed.commentBody
-                  }
-                };
+            if (parsed.teamFilter) {
+              const teams = await linearService.getTeams();
+              const team = teams.find((t) => t.key.toLowerCase() === parsed.teamFilter.toLowerCase() || t.name.toLowerCase() === parsed.teamFilter.toLowerCase());
+              if (team) {
+                teamId = team.id;
+                logger7.info(`Filtering projects by team: ${team.name} (${team.key})`);
               }
-            } else {
-              throw new Error("No issue identifier or description found");
-            }
-            if (parsed.commentType && parsed.commentType !== "note") {
-              commentBody = `[${parsed.commentType.toUpperCase()}] ${commentBody}`;
             }
+            showAll = parsed.showAll === true;
+            stateFilter = parsed.stateFilter;
           } catch (parseError) {
-            logger7.warn("Failed to parse LLM response, falling back to regex:", parseError);
-            const issueMatch = content.match(/(?:comment on|add.*comment.*to|reply to|tell)\s+(\w+-\d+):?\s*(.*)/i);
-            if (!issueMatch) {
-              const errorMessage = 'Please specify the issue ID and comment content. Example: "Comment on ENG-123: This looks good"';
-              await callback?.({
-                text: errorMessage,
-                source: message.content.source
-              });
-              return {
-                text: errorMessage,
-                success: false
-              };
+            logger7.warn("Failed to parse project filters, using basic parsing:", parseError);
+            const teamMatch = content.match(/(?:for|in|of)\s+(?:the\s+)?(\w+)\s+team/i);
+            if (teamMatch) {
+              const teams = await linearService.getTeams();
+              const team = teams.find((t) => t.key.toLowerCase() === teamMatch[1].toLowerCase() || t.name.toLowerCase() === teamMatch[1].toLowerCase());
+              if (team) {
+                teamId = team.id;
+                logger7.info(`Filtering projects by team: ${team.name} (${team.key})`);
+              }
             }
-            issueId = issueMatch[1];
-            commentBody = issueMatch[2].trim();
+            showAll = content.toLowerCase().includes("all") && content.toLowerCase().includes("project");
           }
         }
       }
-      if (!commentBody || commentBody.length === 0) {
-        const errorMessage = "Please provide the comment content.";
+      if (!teamId && !showAll) {
+        const defaultTeamKey = runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
+        if (defaultTeamKey) {
+          const teams = await linearService.getTeams();
+          const defaultTeam = teams.find((t) => t.key.toLowerCase() === defaultTeamKey.toLowerCase());
+          if (defaultTeam) {
+            teamId = defaultTeam.id;
+            logger7.info(`Applying default team filter for projects: ${defaultTeam.name} (${defaultTeam.key})`);
+          }
+        }
+      }
+      let projects = await linearService.getProjects(teamId);
+      if (stateFilter && stateFilter !== "all") {
+        projects = projects.filter((project) => {
+          const state = project.state?.toLowerCase() || "";
+          if (stateFilter === "active") {
+            return state === "started" || state === "in progress" || !state;
+          } else if (stateFilter === "planned") {
+            return state === "planned" || state === "backlog";
+          } else if (stateFilter === "completed") {
+            return state === "completed" || state === "done" || state === "canceled";
+          }
+          return true;
+        });
+      }
+      if (projects.length === 0) {
+        const noProjectsMessage = teamId ? "No projects found for the specified team." : "No projects found in Linear.";
         await callback?.({
-          text: errorMessage,
+          text: noProjectsMessage,
           source: message.content.source
         });
         return {
-          text: errorMessage,
-          success: false
+          text: noProjectsMessage,
+          success: true,
+          data: {
+            projects: []
+          }
         };
       }
-      const issue = await linearService.getIssue(issueId);
-      const comment = await linearService.createComment({
-        issueId: issue.id,
-        body: commentBody
-      });
-      const successMessage = `\u2705 Comment added to issue ${issue.identifier}: "${commentBody}"`;
+      const projectsWithDetails = await Promise.all(projects.map(async (project) => {
+        const teamsQuery = await project.teams();
+        const teams = await teamsQuery.nodes;
+        const lead = await project.lead;
+        return {
+          ...project,
+          teamsList: teams,
+          leadUser: lead
+        };
+      }));
+      const projectList = projectsWithDetails.map((project, index) => {
+        const teamNames = project.teamsList.map((t) => t.name).join(", ") || "No teams";
+        const status = project.state || "Active";
+        const progress = project.progress ? ` (${Math.round(project.progress * 100)}% complete)` : "";
+        const lead = project.leadUser ? ` | Lead: ${project.leadUser.name}` : "";
+        const dates = [];
+        if (project.startDate)
+          dates.push(`Start: ${new Date(project.startDate).toLocaleDateString()}`);
+        if (project.targetDate)
+          dates.push(`Due: ${new Date(project.targetDate).toLocaleDateString()}`);
+        const dateInfo = dates.length > 0 ? `
+   ${dates.join(" | ")}` : "";
+        return `${index + 1}. ${project.name}${project.description ? ` - ${project.description}` : ""}
+   Status: ${status}${progress} | Teams: ${teamNames}${lead}${dateInfo}`;
+      }).join(`
+
+`);
+      const headerText = stateFilter && stateFilter !== "all" ? `\uD83D\uDCC1 Found ${projects.length} ${stateFilter} project${projects.length === 1 ? "" : "s"}:` : `\uD83D\uDCC1 Found ${projects.length} project${projects.length === 1 ? "" : "s"}:`;
+      const resultMessage = `${headerText}
+
+${projectList}`;
       await callback?.({
-        text: successMessage,
+        text: resultMessage,
         source: message.content.source
       });
       return {
-        text: `Added comment to issue ${issue.identifier}`,
+        text: `Found ${projects.length} project${projects.length === 1 ? "" : "s"}`,
         success: true,
         data: {
-          commentId: comment.id,
-          issueId: issue.id,
-          issueIdentifier: issue.identifier,
-          commentBody,
-          createdAt: comment.createdAt
+          projects: projectsWithDetails.map((p) => ({
+            id: p.id,
+            name: p.name,
+            description: p.description,
+            url: p.url,
+            teams: p.teamsList.map((t) => ({
+              id: t.id,
+              name: t.name,
+              key: t.key
+            })),
+            lead: p.leadUser ? {
+              id: p.leadUser.id,
+              name: p.leadUser.name,
+              email: p.leadUser.email
+            } : null,
+            state: p.state,
+            progress: p.progress,
+            startDate: p.startDate,
+            targetDate: p.targetDate
+          })),
+          count: projects.length,
+          filters: {
+            team: teamId,
+            state: stateFilter
+          }
         }
       };
     } catch (error) {
-      logger7.error("Failed to create comment:", error);
-      const errorMessage = `\u274C Failed to create comment: ${error instanceof Error ? error.message : "Unknown error"}`;
+      logger7.error("Failed to list projects:", error);
+      const errorMessage = `❌ Failed to list projects: ${error instanceof Error ? error.message : "Unknown error"}`;
       await callback?.({
         text: errorMessage,
         source: message.content.source
@@ -1889,84 +1615,64 @@ Please specify which issue to comment on by its ID.`;
 };
 
 // src/actions/listTeams.ts
-import { logger as logger8, ModelType as ModelType7 } from "@elizaos/core";
-var listTeamsTemplate = `Extract team filter criteria from the user's request.
-
-User request: "{{userMessage}}"
-
-The user might ask for teams in various ways:
-- "Show me all teams" \u2192 list all teams
-- "Engineering teams" \u2192 filter by teams with engineering in name/description
-- "List teams I'm part of" \u2192 filter by membership
-- "Which teams work on the mobile app?" \u2192 filter by description/focus
-- "Show me the ELIZA team details" \u2192 specific team lookup
-- "Active teams" \u2192 teams with recent activity
-- "Frontend and backend teams" \u2192 multiple team types
-
-Return ONLY a JSON object:
-{
-  "nameFilter": "Keywords to search in team names",
-  "specificTeam": "Specific team name or key if looking for one team",
-  "myTeams": true/false (true if user wants their teams),
-  "showAll": true/false (true if user explicitly asks for "all"),
-  "includeDetails": true/false (true if user wants detailed info)
-}
-
-Only include fields that are clearly mentioned.`;
+import {
+  logger as logger8,
+  ModelType as ModelType7
+} from "@elizaos/core";
 var listTeamsAction = {
   name: "LIST_LINEAR_TEAMS",
   description: "List teams in Linear with optional filters",
   similes: ["list-linear-teams", "show-linear-teams", "get-linear-teams", "view-linear-teams"],
-  examples: [[
-    {
-      name: "User",
-      content: {
-        text: "Show me all teams"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll list all the teams in Linear for you.",
-        actions: ["LIST_LINEAR_TEAMS"]
+  examples: [
+    [
+      {
+        name: "User",
+        content: {
+          text: "Show me all teams"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll list all the teams in Linear for you.",
+          actions: ["LIST_LINEAR_TEAMS"]
+        }
       }
-    }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "Which engineering teams do we have?"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "Let me find the engineering teams for you.",
-        actions: ["LIST_LINEAR_TEAMS"]
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "Which engineering teams do we have?"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "Let me find the engineering teams for you.",
+          actions: ["LIST_LINEAR_TEAMS"]
+        }
       }
-    }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "Show me the teams I'm part of"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll show you the teams you're a member of.",
-        actions: ["LIST_LINEAR_TEAMS"]
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "Show me the teams I'm part of"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll show you the teams you're a member of.",
+          actions: ["LIST_LINEAR_TEAMS"]
+        }
       }
-    }
-  ]],
+    ]
+  ],
   async validate(runtime, _message, _state) {
-    try {
-      const apiKey = runtime.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    } catch {
-      return false;
-    }
+    const apiKey = runtime.getSetting("LINEAR_API_KEY");
+    return !!apiKey;
   },
   async handler(runtime, message, _state, _options, callback) {
     try {
@@ -1998,9 +1704,7 @@ var listTeamsAction = {
       }
       let teams = await linearService.getTeams();
       if (specificTeam) {
-        teams = teams.filter(
-          (team) => team.key.toLowerCase() === specificTeam.toLowerCase() || team.name.toLowerCase() === specificTeam.toLowerCase()
-        );
+        teams = teams.filter((team) => team.key.toLowerCase() === specificTeam.toLowerCase() || team.name.toLowerCase() === specificTeam.toLowerCase());
       }
       if (nameFilter && !specificTeam) {
         const keywords = nameFilter.toLowerCase().split(/\s+/);
@@ -2011,10 +1715,11 @@ var listTeamsAction = {
       }
       if (myTeams) {
         try {
-          const currentUser = await linearService.getCurrentUser();
-          logger8.info("Team membership filtering not yet implemented");
-        } catch {
-          logger8.warn("Could not get current user for team filtering");
+          const userTeams = await linearService.getUserTeams();
+          const userTeamIds = new Set(userTeams.map((t) => t.id));
+          teams = teams.filter((team) => userTeamIds.has(team.id));
+        } catch (error) {
+          logger8.warn("Could not filter for user's teams:", error);
         }
       }
       if (teams.length === 0) {
@@ -2038,13 +1743,11 @@ var listTeamsAction = {
           const members = await membersQuery.nodes;
           const projectsQuery = await team.projects();
           const projects = await projectsQuery.nodes;
-          return {
-            ...team,
+          return Object.assign(team, {
             memberCount: members.length,
             projectCount: projects.length,
             membersList: specificTeam ? members.slice(0, 5) : []
-            // Include member details for specific team
-          };
+          });
         }));
       }
       const teamList = teamsWithDetails.map((team, index) => {
@@ -2055,16 +1758,19 @@ var listTeamsAction = {
         }
         if (includeDetails || specificTeam) {
           info += `
-   Members: ${team.memberCount} | Projects: ${team.projectCount}`;
-          if (specificTeam && team.membersList.length > 0) {
-            const memberNames = team.membersList.map((m) => m.name).join(", ");
+   Members: ${team.memberCount ?? 0} | Projects: ${team.projectCount ?? 0}`;
+          const membersList = team.membersList ?? [];
+          if (specificTeam && membersList.length > 0) {
+            const memberNames = membersList.map((m) => m.name).join(", ");
             info += `
-   Team members: ${memberNames}${team.memberCount > 5 ? " ..." : ""}`;
+   Team members: ${memberNames}${(team.memberCount ?? 0) > 5 ? " ..." : ""}`;
           }
         }
         return info;
-      }).join("\n\n");
-      const headerText = specificTeam && teams.length === 1 ? `\u{1F4CB} Team Details:` : nameFilter ? `\u{1F4CB} Found ${teams.length} team${teams.length === 1 ? "" : "s"} matching "${nameFilter}":` : `\u{1F4CB} Found ${teams.length} team${teams.length === 1 ? "" : "s"}:`;
+      }).join(`
+
+`);
+      const headerText = specificTeam && teams.length === 1 ? `\uD83D\uDCCB Team Details:` : nameFilter ? `\uD83D\uDCCB Found ${teams.length} team${teams.length === 1 ? "" : "s"} matching "${nameFilter}":` : `\uD83D\uDCCB Found ${teams.length} team${teams.length === 1 ? "" : "s"}:`;
       const resultMessage = `${headerText}
 
 ${teamList}`;
@@ -2093,7 +1799,7 @@ ${teamList}`;
       };
     } catch (error) {
       logger8.error("Failed to list teams:", error);
-      const errorMessage = `\u274C Failed to list teams: ${error instanceof Error ? error.message : "Unknown error"}`;
+      const errorMessage = `❌ Failed to list teams: ${error instanceof Error ? error.message : "Unknown error"}`;
       await callback?.({
         text: errorMessage,
         source: message.content.source
@@ -2106,91 +1812,71 @@ ${teamList}`;
   }
 };
 
-// src/actions/listProjects.ts
-import { logger as logger9, ModelType as ModelType8 } from "@elizaos/core";
-var listProjectsTemplate = `Extract project filter criteria from the user's request.
-
-User request: "{{userMessage}}"
-
-The user might ask for projects in various ways:
-- "Show me all projects" \u2192 list all projects
-- "Active projects" \u2192 filter by state (active/planned/completed)
-- "Projects due this quarter" \u2192 filter by target date
-- "Which projects is Sarah managing?" \u2192 filter by lead/owner
-- "Projects with high priority issues" \u2192 filter by contained issue priority
-- "Projects for the engineering team" \u2192 filter by team
-- "Completed projects" \u2192 filter by state
-- "Projects starting next month" \u2192 filter by start date
-
-Return ONLY a JSON object:
-{
-  "teamFilter": "Team name or key if mentioned",
-  "stateFilter": "active/planned/completed/all",
-  "dateFilter": {
-    "type": "due/starting",
-    "period": "this-week/this-month/this-quarter/next-month/next-quarter",
-    "from": "ISO date if specific",
-    "to": "ISO date if specific"
-  },
-  "leadFilter": "Project lead name if mentioned",
-  "showAll": true/false (true if user explicitly asks for "all")
-}
-
-Only include fields that are clearly mentioned.`;
-var listProjectsAction = {
-  name: "LIST_LINEAR_PROJECTS",
-  description: "List projects in Linear with optional filters",
-  similes: ["list-linear-projects", "show-linear-projects", "get-linear-projects", "view-linear-projects"],
-  examples: [[
-    {
-      name: "User",
-      content: {
-        text: "Show me all projects"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll list all the projects in Linear for you.",
-        actions: ["LIST_LINEAR_PROJECTS"]
+// src/actions/searchIssues.ts
+import {
+  logger as logger9,
+  ModelType as ModelType8
+} from "@elizaos/core";
+var searchTemplate = searchIssuesTemplate;
+var searchIssuesAction = {
+  name: "SEARCH_LINEAR_ISSUES",
+  description: "Search for issues in Linear with various filters",
+  similes: [
+    "search-linear-issues",
+    "find-linear-issues",
+    "query-linear-issues",
+    "list-linear-issues"
+  ],
+  examples: [
+    [
+      {
+        name: "User",
+        content: {
+          text: "Show me all open bugs"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll search for all open bug issues in Linear.",
+          actions: ["SEARCH_LINEAR_ISSUES"]
+        }
       }
-    }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "What active projects do we have?"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "Let me show you all the active projects.",
-        actions: ["LIST_LINEAR_PROJECTS"]
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "What is John working on?"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll find the issues assigned to John.",
+          actions: ["SEARCH_LINEAR_ISSUES"]
+        }
       }
-    }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "Show me projects for the engineering team"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll find the projects for the engineering team.",
-        actions: ["LIST_LINEAR_PROJECTS"]
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "Show me high priority issues created this week"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll search for high priority issues created this week.",
+          actions: ["SEARCH_LINEAR_ISSUES"]
+        }
       }
-    }
-  ]],
+    ]
+  ],
   async validate(runtime, _message, _state) {
-    try {
-      const apiKey = runtime.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    } catch {
-      return false;
-    }
+    const apiKey = runtime.getSetting("LINEAR_API_KEY");
+    return !!apiKey;
   },
   async handler(runtime, message, _state, _options, callback) {
     try {
@@ -2198,158 +1884,168 @@ var listProjectsAction = {
       if (!linearService) {
         throw new Error("Linear service not available");
       }
-      const content = message.content.text || "";
-      let teamId;
-      let showAll = false;
-      let stateFilter;
-      if (content) {
-        const prompt = listProjectsTemplate.replace("{{userMessage}}", content);
+      const content = message.content.text;
+      if (!content) {
+        const errorMessage = "Please provide search criteria for issues.";
+        await callback?.({
+          text: errorMessage,
+          source: message.content.source
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      let filters = {};
+      const params = _options?.parameters;
+      if (params?.filters) {
+        filters = params.filters;
+      } else {
+        const prompt = searchTemplate.replace("{{userMessage}}", content);
         const response = await runtime.useModel(ModelType8.TEXT_LARGE, {
           prompt
         });
-        if (response) {
+        if (!response) {
+          filters = { query: content };
+        } else {
           try {
-            const parsed = JSON.parse(response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim());
-            if (parsed.teamFilter) {
-              const teams = await linearService.getTeams();
-              const team = teams.find(
-                (t) => t.key.toLowerCase() === parsed.teamFilter.toLowerCase() || t.name.toLowerCase() === parsed.teamFilter.toLowerCase()
-              );
-              if (team) {
-                teamId = team.id;
-                logger9.info(`Filtering projects by team: ${team.name} (${team.key})`);
+            const cleanedResponse = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
+            const parsed = JSON.parse(cleanedResponse);
+            filters = {
+              query: parsed.query,
+              limit: parsed.limit || 10
+            };
+            if (parsed.states && parsed.states.length > 0) {
+              filters.state = parsed.states;
+            }
+            if (parsed.assignees && parsed.assignees.length > 0) {
+              const processedAssignees = [];
+              for (const assignee of parsed.assignees) {
+                if (assignee.toLowerCase() === "me") {
+                  try {
+                    const currentUser = await linearService.getCurrentUser();
+                    processedAssignees.push(currentUser.email);
+                  } catch {
+                    logger9.warn('Could not resolve "me" to current user');
+                  }
+                } else {
+                  processedAssignees.push(assignee);
+                }
+              }
+              if (processedAssignees.length > 0) {
+                filters.assignee = processedAssignees;
               }
             }
-            showAll = parsed.showAll === true;
-            stateFilter = parsed.stateFilter;
-            if (parsed.dateFilter || parsed.leadFilter) {
-              logger9.info("Date and lead filters noted but not yet implemented");
+            if (parsed.hasAssignee === false) {
+              filters.query = filters.query ? `${filters.query} unassigned` : "unassigned";
             }
-          } catch (parseError) {
-            logger9.warn("Failed to parse project filters, using basic parsing:", parseError);
-            const teamMatch = content.match(/(?:for|in|of)\s+(?:the\s+)?(\w+)\s+team/i);
-            if (teamMatch) {
-              const teams = await linearService.getTeams();
-              const team = teams.find(
-                (t) => t.key.toLowerCase() === teamMatch[1].toLowerCase() || t.name.toLowerCase() === teamMatch[1].toLowerCase()
-              );
-              if (team) {
-                teamId = team.id;
-                logger9.info(`Filtering projects by team: ${team.name} (${team.key})`);
+            if (parsed.priorities && parsed.priorities.length > 0) {
+              const priorityMap = {
+                urgent: 1,
+                high: 2,
+                normal: 3,
+                low: 4,
+                "1": 1,
+                "2": 2,
+                "3": 3,
+                "4": 4
+              };
+              const priorities = parsed.priorities.map((p) => priorityMap[p.toLowerCase()]).filter(Boolean);
+              if (priorities.length > 0) {
+                filters.priority = priorities;
               }
             }
-            showAll = content.toLowerCase().includes("all") && content.toLowerCase().includes("project");
+            if (parsed.teams && parsed.teams.length > 0) {
+              filters.team = parsed.teams[0];
+            }
+            if (parsed.labels && parsed.labels.length > 0) {
+              filters.label = parsed.labels;
+            }
+            Object.keys(filters).forEach((key) => {
+              if (filters[key] === undefined) {
+                delete filters[key];
+              }
+            });
+          } catch (parseError) {
+            logger9.error("Failed to parse search filters:", parseError);
+            filters = { query: content };
           }
         }
       }
-      if (!teamId && !showAll) {
+      if (!filters.team) {
         const defaultTeamKey = runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
         if (defaultTeamKey) {
-          const teams = await linearService.getTeams();
-          const defaultTeam = teams.find(
-            (t) => t.key.toLowerCase() === defaultTeamKey.toLowerCase()
-          );
-          if (defaultTeam) {
-            teamId = defaultTeam.id;
-            logger9.info(`Applying default team filter for projects: ${defaultTeam.name} (${defaultTeam.key})`);
+          const searchingAllIssues = content.toLowerCase().includes("all") && (content.toLowerCase().includes("issue") || content.toLowerCase().includes("bug") || content.toLowerCase().includes("task"));
+          if (!searchingAllIssues) {
+            filters.team = defaultTeamKey;
+            logger9.info(`Applying default team filter: ${defaultTeamKey}`);
           }
         }
       }
-      let projects = await linearService.getProjects(teamId);
-      if (stateFilter && stateFilter !== "all") {
-        projects = projects.filter((project) => {
-          const state = project.state?.toLowerCase() || "";
-          if (stateFilter === "active") {
-            return state === "started" || state === "in progress" || !state;
-          } else if (stateFilter === "planned") {
-            return state === "planned" || state === "backlog";
-          } else if (stateFilter === "completed") {
-            return state === "completed" || state === "done" || state === "canceled";
-          }
-          return true;
-        });
-      }
-      if (projects.length === 0) {
-        const noProjectsMessage = teamId ? "No projects found for the specified team." : "No projects found in Linear.";
+      filters.limit = params?.limit ?? filters.limit ?? 10;
+      const issues = await linearService.searchIssues(filters);
+      if (issues.length === 0) {
+        const noResultsMessage = "No issues found matching your search criteria.";
         await callback?.({
-          text: noProjectsMessage,
+          text: noResultsMessage,
           source: message.content.source
         });
         return {
-          text: noProjectsMessage,
+          text: noResultsMessage,
           success: true,
           data: {
-            projects: []
+            issues: [],
+            filters: filters ? { ...filters } : undefined,
+            count: 0
           }
         };
       }
-      const projectsWithDetails = await Promise.all(
-        projects.map(async (project) => {
-          const teamsQuery = await project.teams();
-          const teams = await teamsQuery.nodes;
-          const lead = await project.lead;
-          return {
-            ...project,
-            teamsList: teams,
-            leadUser: lead
-          };
-        })
-      );
-      const projectList = projectsWithDetails.map((project, index) => {
-        const teamNames = project.teamsList.map((t) => t.name).join(", ") || "No teams";
-        const status = project.state || "Active";
-        const progress = project.progress ? ` (${Math.round(project.progress * 100)}% complete)` : "";
-        const lead = project.leadUser ? ` | Lead: ${project.leadUser.name}` : "";
-        const dates = [];
-        if (project.startDate) dates.push(`Start: ${new Date(project.startDate).toLocaleDateString()}`);
-        if (project.targetDate) dates.push(`Due: ${new Date(project.targetDate).toLocaleDateString()}`);
-        const dateInfo = dates.length > 0 ? `
-   ${dates.join(" | ")}` : "";
-        return `${index + 1}. ${project.name}${project.description ? ` - ${project.description}` : ""}
-   Status: ${status}${progress} | Teams: ${teamNames}${lead}${dateInfo}`;
-      }).join("\n\n");
-      const headerText = stateFilter && stateFilter !== "all" ? `\u{1F4C1} Found ${projects.length} ${stateFilter} project${projects.length === 1 ? "" : "s"}:` : `\u{1F4C1} Found ${projects.length} project${projects.length === 1 ? "" : "s"}:`;
-      const resultMessage = `${headerText}
+      const issueList = await Promise.all(issues.map(async (issue, index) => {
+        const state = await issue.state;
+        const assignee = await issue.assignee;
+        const priorityLabels = ["", "Urgent", "High", "Normal", "Low"];
+        const priority = priorityLabels[issue.priority || 0] || "No priority";
+        return `${index + 1}. ${issue.identifier}: ${issue.title}
+   Status: ${state?.name || "No state"} | Priority: ${priority} | Assignee: ${assignee?.name || "Unassigned"}`;
+      }));
+      const issueText = issueList.join(`
 
-${projectList}`;
+`);
+      const resultMessage = `\uD83D\uDCCB Found ${issues.length} issue${issues.length === 1 ? "" : "s"}:
+
+${issueText}`;
       await callback?.({
         text: resultMessage,
         source: message.content.source
       });
       return {
-        text: `Found ${projects.length} project${projects.length === 1 ? "" : "s"}`,
+        text: `Found ${issues.length} issue${issues.length === 1 ? "" : "s"}`,
         success: true,
         data: {
-          projects: projectsWithDetails.map((p) => ({
-            id: p.id,
-            name: p.name,
-            description: p.description,
-            url: p.url,
-            teams: p.teamsList.map((t) => ({
-              id: t.id,
-              name: t.name,
-              key: t.key
-            })),
-            lead: p.leadUser ? {
-              id: p.leadUser.id,
-              name: p.leadUser.name,
-              email: p.leadUser.email
-            } : null,
-            state: p.state,
-            progress: p.progress,
-            startDate: p.startDate,
-            targetDate: p.targetDate
+          issues: await Promise.all(issues.map(async (issue) => {
+            const state = await issue.state;
+            const assignee = await issue.assignee;
+            const team = await issue.team;
+            return {
+              id: issue.id,
+              identifier: issue.identifier,
+              title: issue.title,
+              url: issue.url,
+              priority: issue.priority,
+              state: state ? { name: state.name, type: state.type } : null,
+              assignee: assignee ? { name: assignee.name, email: assignee.email } : null,
+              team: team ? { name: team.name, key: team.key } : null,
+              createdAt: issue.createdAt instanceof Date ? issue.createdAt.toISOString() : issue.createdAt,
+              updatedAt: issue.updatedAt instanceof Date ? issue.updatedAt.toISOString() : issue.updatedAt
+            };
           })),
-          count: projects.length,
-          filters: {
-            team: teamId,
-            state: stateFilter
-          }
+          filters: filters ? { ...filters } : undefined,
+          count: issues.length
         }
       };
     } catch (error) {
-      logger9.error("Failed to list projects:", error);
-      const errorMessage = `\u274C Failed to list projects: ${error instanceof Error ? error.message : "Unknown error"}`;
+      logger9.error("Failed to search issues:", error);
+      const errorMessage = `❌ Failed to search issues: ${error instanceof Error ? error.message : "Unknown error"}`;
       await callback?.({
         text: errorMessage,
         source: message.content.source
@@ -2362,90 +2058,71 @@ ${projectList}`;
   }
 };
 
-// src/actions/getActivity.ts
-import { logger as logger10, ModelType as ModelType9 } from "@elizaos/core";
-var getActivityTemplate = `Extract activity filter criteria from the user's request.
-
-User request: "{{userMessage}}"
-
-The user might ask for activity in various ways:
-- "Show me today's activity" \u2192 time range filter
-- "What issues were created?" \u2192 action type filter
-- "What did John do yesterday?" \u2192 user filter + time range
-- "Activity on ENG-123" \u2192 resource filter
-- "Recent comment activity" \u2192 action type + recency
-- "Failed operations this week" \u2192 success filter + time range
-
-Return ONLY a JSON object:
-{
-  "timeRange": {
-    "period": "today/yesterday/this-week/last-week/this-month",
-    "from": "ISO datetime if specific",
-    "to": "ISO datetime if specific"
-  },
-  "actionTypes": ["create_issue/update_issue/delete_issue/create_comment/search_issues/etc"],
-  "resourceTypes": ["issue/project/comment/team"],
-  "resourceId": "Specific resource ID if mentioned (e.g., ENG-123)",
-  "user": "User name or 'me' for current user",
-  "successFilter": "success/failed/all",
-  "limit": number (default 10)
-}
-
-Only include fields that are clearly mentioned.`;
-var getActivityAction = {
-  name: "GET_LINEAR_ACTIVITY",
-  description: "Get recent Linear activity log with optional filters",
-  similes: ["get-linear-activity", "show-linear-activity", "view-linear-activity", "check-linear-activity"],
-  examples: [[
-    {
-      name: "User",
-      content: {
-        text: "Show me recent Linear activity"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll show you the recent Linear activity.",
-        actions: ["GET_LINEAR_ACTIVITY"]
+// src/actions/updateIssue.ts
+import {
+  logger as logger10,
+  ModelType as ModelType9
+} from "@elizaos/core";
+var updateIssueAction = {
+  name: "UPDATE_LINEAR_ISSUE",
+  description: "Update an existing Linear issue",
+  similes: [
+    "update-linear-issue",
+    "edit-linear-issue",
+    "modify-linear-issue",
+    "move-linear-issue",
+    "change-linear-issue"
+  ],
+  examples: [
+    [
+      {
+        name: "User",
+        content: {
+          text: 'Update issue ENG-123 title to "Fix login button on all devices"'
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll update the title of issue ENG-123 for you.",
+          actions: ["UPDATE_LINEAR_ISSUE"]
+        }
       }
-    }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "What happened in Linear today?"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "Let me check today's Linear activity for you.",
-        actions: ["GET_LINEAR_ACTIVITY"]
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "Move issue COM2-7 to the ELIZA team"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll move issue COM2-7 to the ELIZA team.",
+          actions: ["UPDATE_LINEAR_ISSUE"]
+        }
       }
-    }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "Show me what issues John created this week"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll find the issues John created this week.",
-        actions: ["GET_LINEAR_ACTIVITY"]
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "Change the priority of BUG-456 to high and assign to john@example.com"
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll change the priority of BUG-456 to high and assign it to john@example.com.",
+          actions: ["UPDATE_LINEAR_ISSUE"]
+        }
       }
-    }
-  ]],
+    ]
+  ],
   async validate(runtime, _message, _state) {
-    try {
-      const apiKey = runtime.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    } catch {
-      return false;
-    }
+    const apiKey = runtime.getSetting("LINEAR_API_KEY");
+    return !!apiKey;
   },
   async handler(runtime, message, _state, _options, callback) {
     try {
@@ -2453,115 +2130,176 @@ var getActivityAction = {
       if (!linearService) {
         throw new Error("Linear service not available");
       }
-      const content = message.content.text || "";
-      let filters = {};
-      let limit = 10;
-      if (content) {
-        const prompt = getActivityTemplate.replace("{{userMessage}}", content);
-        const response = await runtime.useModel(ModelType9.TEXT_LARGE, {
-          prompt
+      const content = message.content.text;
+      if (!content) {
+        const errorMessage = "Please provide update instructions for the issue.";
+        await callback?.({
+          text: errorMessage,
+          source: message.content.source
         });
-        if (response) {
-          try {
-            const parsed = JSON.parse(response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim());
-            if (parsed.timeRange) {
-              const now = /* @__PURE__ */ new Date();
-              let fromDate;
-              if (parsed.timeRange.from) {
-                fromDate = new Date(parsed.timeRange.from);
-              } else if (parsed.timeRange.period) {
-                switch (parsed.timeRange.period) {
-                  case "today":
-                    fromDate = new Date(now.setHours(0, 0, 0, 0));
-                    break;
-                  case "yesterday":
-                    fromDate = new Date(now.setDate(now.getDate() - 1));
-                    fromDate.setHours(0, 0, 0, 0);
-                    break;
-                  case "this-week":
-                    fromDate = new Date(now.setDate(now.getDate() - now.getDay()));
-                    fromDate.setHours(0, 0, 0, 0);
-                    break;
-                  case "last-week":
-                    fromDate = new Date(now.setDate(now.getDate() - now.getDay() - 7));
-                    fromDate.setHours(0, 0, 0, 0);
-                    break;
-                  case "this-month":
-                    fromDate = new Date(now.getFullYear(), now.getMonth(), 1);
-                    break;
-                }
-              }
-              if (fromDate) {
-                filters.fromDate = fromDate.toISOString();
-              }
-            }
-            if (parsed.actionTypes && parsed.actionTypes.length > 0) {
-              filters.action = parsed.actionTypes[0];
-            }
-            if (parsed.resourceTypes && parsed.resourceTypes.length > 0) {
-              filters.resource_type = parsed.resourceTypes[0];
-            }
-            if (parsed.resourceId) {
-              filters.resource_id = parsed.resourceId;
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const prompt = updateIssueTemplate.replace("{{userMessage}}", content);
+      const response = await runtime.useModel(ModelType9.TEXT_LARGE, {
+        prompt
+      });
+      if (!response) {
+        throw new Error("Failed to extract update information");
+      }
+      let issueId;
+      const updates = {};
+      try {
+        const cleanedResponse = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
+        const parsed = JSON.parse(cleanedResponse);
+        issueId = parsed.issueId;
+        if (!issueId) {
+          throw new Error("Issue ID not found in parsed response");
+        }
+        if (parsed.updates?.title) {
+          updates.title = parsed.updates.title;
+        }
+        if (parsed.updates?.description) {
+          updates.description = parsed.updates.description;
+        }
+        if (parsed.updates?.priority) {
+          updates.priority = Number(parsed.updates.priority);
+        }
+        if (parsed.updates?.teamKey) {
+          const teams = await linearService.getTeams();
+          const team = teams.find((t) => t.key.toLowerCase() === parsed.updates.teamKey.toLowerCase());
+          if (team) {
+            updates.teamId = team.id;
+            logger10.info(`Moving issue to team: ${team.name} (${team.key})`);
+          } else {
+            logger10.warn(`Team with key ${parsed.updates.teamKey} not found`);
+          }
+        }
+        if (parsed.updates?.assignee) {
+          const cleanAssignee = parsed.updates.assignee.replace(/^@/, "");
+          const users = await linearService.getUsers();
+          const user = users.find((u) => u.email === cleanAssignee || u.name.toLowerCase().includes(cleanAssignee.toLowerCase()));
+          if (user) {
+            updates.assigneeId = user.id;
+          } else {
+            logger10.warn(`User ${cleanAssignee} not found`);
+          }
+        }
+        if (parsed.updates?.status) {
+          const issue = await linearService.getIssue(issueId);
+          const issueTeam = await issue.team;
+          const teamId = updates.teamId || issueTeam?.id;
+          if (!teamId) {
+            logger10.warn("Could not determine team for status update");
+          } else {
+            const states = await linearService.getWorkflowStates(teamId);
+            const state = states.find((s) => s.name.toLowerCase() === parsed.updates.status.toLowerCase() || s.type.toLowerCase() === parsed.updates.status.toLowerCase());
+            if (state) {
+              updates.stateId = state.id;
+              logger10.info(`Changing status to: ${state.name}`);
+            } else {
+              logger10.warn(`Status ${parsed.updates.status} not found for team`);
             }
-            if (parsed.successFilter && parsed.successFilter !== "all") {
-              filters.success = parsed.successFilter === "success";
+          }
+        }
+        if (parsed.updates?.labels && Array.isArray(parsed.updates.labels)) {
+          const teamId = updates.teamId;
+          const labels = await linearService.getLabels(teamId);
+          const labelIds = [];
+          for (const labelName of parsed.updates.labels) {
+            if (labelName) {
+              const label = labels.find((l) => l.name.toLowerCase() === labelName.toLowerCase());
+              if (label) {
+                labelIds.push(label.id);
+              }
             }
-            limit = parsed.limit || 10;
-          } catch (parseError) {
-            logger10.warn("Failed to parse activity filters:", parseError);
+          }
+          updates.labelIds = labelIds;
+        }
+      } catch (parseError) {
+        logger10.warn("Failed to parse LLM response, falling back to regex parsing:", parseError);
+        const issueMatch = content.match(/(\w+-\d+)/);
+        if (!issueMatch) {
+          const errorMessage = "Please specify an issue ID (e.g., ENG-123) to update.";
+          await callback?.({
+            text: errorMessage,
+            source: message.content.source
+          });
+          return {
+            text: errorMessage,
+            success: false
+          };
+        }
+        issueId = issueMatch[1];
+        const titleMatch = content.match(/title to ["'](.+?)["']/i);
+        if (titleMatch) {
+          updates.title = titleMatch[1];
+        }
+        const priorityMatch = content.match(/priority (?:to |as )?(\w+)/i);
+        if (priorityMatch) {
+          const priorityMap = {
+            urgent: 1,
+            high: 2,
+            normal: 3,
+            medium: 3,
+            low: 4
+          };
+          const priority = priorityMap[priorityMatch[1].toLowerCase()];
+          if (priority) {
+            updates.priority = priority;
           }
         }
       }
-      let activity = linearService.getActivityLog(limit * 2, filters);
-      if (filters.fromDate) {
-        const fromTime = new Date(filters.fromDate).getTime();
-        activity = activity.filter((item) => new Date(item.timestamp).getTime() >= fromTime);
-      }
-      activity = activity.slice(0, limit);
-      if (activity.length === 0) {
-        const noActivityMessage = filters.fromDate ? `No Linear activity found for the specified filters.` : "No recent Linear activity found.";
+      if (Object.keys(updates).length === 0) {
+        const errorMessage = `No valid updates found. Please specify what to update (e.g., "Update issue ENG-123 title to 'New Title'")`;
         await callback?.({
-          text: noActivityMessage,
+          text: errorMessage,
           source: message.content.source
         });
         return {
-          text: noActivityMessage,
-          success: true,
-          data: {
-            activity: []
-          }
+          text: errorMessage,
+          success: false
         };
       }
-      const activityText = activity.map((item, index) => {
-        const time = new Date(item.timestamp).toLocaleString();
-        const status = item.success ? "\u2705" : "\u274C";
-        const details = Object.entries(item.details).filter(([key]) => key !== "filters").map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(", ");
-        return `${index + 1}. ${status} ${item.action} on ${item.resource_type} ${item.resource_id}
-   Time: ${time}
-   ${details ? `Details: ${details}` : ""}${item.error ? `
-   Error: ${item.error}` : ""}`;
-      }).join("\n\n");
-      const headerText = filters.fromDate ? `\u{1F4CA} Linear activity ${content}:` : "\u{1F4CA} Recent Linear activity:";
-      const resultMessage = `${headerText}
+      const updatedIssue = await linearService.updateIssue(issueId, updates);
+      const updateSummary = [];
+      if (updates.title)
+        updateSummary.push(`title: "${updates.title}"`);
+      if (updates.priority)
+        updateSummary.push(`priority: ${["", "urgent", "high", "normal", "low"][updates.priority]}`);
+      if (updates.teamId)
+        updateSummary.push(`moved to team`);
+      if (updates.assigneeId)
+        updateSummary.push(`assigned to user`);
+      if (updates.stateId)
+        updateSummary.push(`status changed`);
+      if (updates.labelIds)
+        updateSummary.push(`labels updated`);
+      const successMessage = `✅ Updated issue ${updatedIssue.identifier}: ${updateSummary.join(", ")}
 
-${activityText}`;
+View it at: ${updatedIssue.url}`;
       await callback?.({
-        text: resultMessage,
+        text: successMessage,
         source: message.content.source
       });
       return {
-        text: `Found ${activity.length} activity item${activity.length === 1 ? "" : "s"}`,
+        text: `Updated issue ${updatedIssue.identifier}: ${updateSummary.join(", ")}`,
         success: true,
         data: {
-          activity,
-          filters,
-          count: activity.length
+          issueId: updatedIssue.id,
+          identifier: updatedIssue.identifier,
+          updates: updates ? Object.fromEntries(Object.entries(updates).map(([key, value]) => [
+            key,
+            value instanceof Date ? value.toISOString() : value
+          ])) : undefined,
+          url: updatedIssue.url
         }
       };
     } catch (error) {
-      logger10.error("Failed to get activity:", error);
-      const errorMessage = `\u274C Failed to get activity: ${error instanceof Error ? error.message : "Unknown error"}`;
+      logger10.error("Failed to update issue:", error);
+      const errorMessage = `❌ Failed to update issue: ${error instanceof Error ? error.message : "Unknown error"}`;
       await callback?.({
         text: errorMessage,
         source: message.content.source
@@ -2574,83 +2312,498 @@ ${activityText}`;
   }
 };
 
-// src/actions/clearActivity.ts
-import { logger as logger11 } from "@elizaos/core";
-var clearActivityAction = {
-  name: "CLEAR_LINEAR_ACTIVITY",
-  description: "Clear the Linear activity log",
-  similes: ["clear-linear-activity", "reset-linear-activity", "delete-linear-activity"],
-  examples: [[
-    {
-      name: "User",
-      content: {
-        text: "Clear the Linear activity log"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll clear the Linear activity log for you.",
-        actions: ["CLEAR_LINEAR_ACTIVITY"]
+// src/providers/activity.ts
+var linearActivityProvider = {
+  name: "LINEAR_ACTIVITY",
+  description: "Provides context about recent Linear activity",
+  get: async (runtime, _message, _state) => {
+    try {
+      const linearService = runtime.getService("linear");
+      if (!linearService) {
+        return {
+          text: "Linear service is not available"
+        };
+      }
+      const activity = linearService.getActivityLog(10);
+      if (activity.length === 0) {
+        return {
+          text: "No recent Linear activity"
+        };
       }
+      const activityList = activity.map((item) => {
+        const status = item.success ? "✓" : "✗";
+        const time = new Date(item.timestamp).toLocaleTimeString();
+        return `${status} ${time}: ${item.action} ${item.resource_type} ${item.resource_id}`;
+      });
+      const text = `Recent Linear Activity:
+${activityList.join(`
+`)}`;
+      return {
+        text,
+        data: {
+          activity: activity.slice(0, 10).map((item) => ({
+            id: item.id,
+            action: item.action,
+            resource_type: item.resource_type,
+            resource_id: item.resource_id,
+            success: item.success,
+            error: item.error,
+            details: JSON.stringify(item.details),
+            timestamp: typeof item.timestamp === "string" ? item.timestamp : new Date(item.timestamp).toISOString()
+          }))
+        }
+      };
+    } catch (_error) {
+      return {
+        text: "Error retrieving Linear activity"
+      };
     }
-  ], [
-    {
-      name: "User",
-      content: {
-        text: "Reset Linear activity"
-      }
-    },
-    {
-      name: "Assistant",
-      content: {
-        text: "I'll reset the Linear activity log now.",
-        actions: ["CLEAR_LINEAR_ACTIVITY"]
+  }
+};
+
+// src/providers/issues.ts
+var linearIssuesProvider = {
+  name: "LINEAR_ISSUES",
+  description: "Provides context about recent Linear issues",
+  get: async (runtime, _message, _state) => {
+    try {
+      const linearService = runtime.getService("linear");
+      if (!linearService) {
+        return {
+          text: "Linear service is not available"
+        };
+      }
+      const issues = await linearService.searchIssues({ limit: 10 });
+      if (issues.length === 0) {
+        return {
+          text: "No recent Linear issues found"
+        };
       }
+      const issuesList = await Promise.all(issues.map(async (issue) => {
+        const [assignee, state] = await Promise.all([issue.assignee, issue.state]);
+        return `- ${issue.identifier}: ${issue.title} (${state?.name || "Unknown"}, ${assignee?.name || "Unassigned"})`;
+      }));
+      const text = `Recent Linear Issues:
+${issuesList.join(`
+`)}`;
+      return {
+        text,
+        data: {
+          issues: issues.map((issue) => ({
+            id: issue.id,
+            identifier: issue.identifier,
+            title: issue.title
+          }))
+        }
+      };
+    } catch (_error) {
+      return {
+        text: "Error retrieving Linear issues"
+      };
     }
-  ]],
-  async validate(runtime, _message, _state) {
+  }
+};
+
+// src/providers/projects.ts
+var linearProjectsProvider = {
+  name: "LINEAR_PROJECTS",
+  description: "Provides context about active Linear projects",
+  get: async (runtime, _message, _state) => {
     try {
-      const apiKey = runtime.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    } catch {
-      return false;
+      const linearService = runtime.getService("linear");
+      if (!linearService) {
+        return {
+          text: "Linear service is not available"
+        };
+      }
+      const projects = await linearService.getProjects();
+      if (projects.length === 0) {
+        return {
+          text: "No Linear projects found"
+        };
+      }
+      const activeProjects = projects.filter((project) => project.state === "started" || project.state === "planned");
+      const projectsList = activeProjects.slice(0, 10).map((project) => `- ${project.name}: ${project.state} (${project.startDate || "No start date"} - ${project.targetDate || "No target date"})`);
+      const text = `Active Linear Projects:
+${projectsList.join(`
+`)}`;
+      return {
+        text,
+        data: {
+          projects: activeProjects.slice(0, 10).map((project) => ({
+            id: project.id,
+            name: project.name,
+            state: project.state
+          }))
+        }
+      };
+    } catch (_error) {
+      return {
+        text: "Error retrieving Linear projects"
+      };
     }
-  },
-  async handler(runtime, message, _state, _options, callback) {
+  }
+};
+
+// src/providers/teams.ts
+var linearTeamsProvider = {
+  name: "LINEAR_TEAMS",
+  description: "Provides context about Linear teams",
+  get: async (runtime, _message, _state) => {
     try {
       const linearService = runtime.getService("linear");
       if (!linearService) {
-        throw new Error("Linear service not available");
+        return {
+          text: "Linear service is not available"
+        };
       }
-      await linearService.clearActivityLog();
-      const successMessage = "\u2705 Linear activity log has been cleared.";
-      await callback?.({
-        text: successMessage,
-        source: message.content.source
-      });
+      const teams = await linearService.getTeams();
+      if (teams.length === 0) {
+        return {
+          text: "No Linear teams found"
+        };
+      }
+      const teamsList = teams.map((team) => `- ${team.name} (${team.key}): ${team.description || "No description"}`);
+      const text = `Linear Teams:
+${teamsList.join(`
+`)}`;
       return {
-        text: successMessage,
-        success: true
+        text,
+        data: {
+          teams: teams.map((team) => ({
+            id: team.id,
+            name: team.name,
+            key: team.key
+          }))
+        }
       };
-    } catch (error) {
-      logger11.error("Failed to clear Linear activity:", error);
-      const errorMessage = `\u274C Failed to clear Linear activity: ${error instanceof Error ? error.message : "Unknown error"}`;
-      await callback?.({
-        text: errorMessage,
-        source: message.content.source
-      });
+    } catch (_error) {
       return {
-        text: errorMessage,
-        success: false
+        text: "Error retrieving Linear teams"
       };
     }
   }
 };
 
+// src/services/linear.ts
+import { logger as logger11, Service } from "@elizaos/core";
+import {
+  LinearClient
+} from "@linear/sdk";
+
+// src/types/index.ts
+class LinearAPIError extends Error {
+  status;
+  response;
+  constructor(message, status, response) {
+    super(message);
+    this.status = status;
+    this.response = response;
+    this.name = "LinearAPIError";
+  }
+}
+
+class LinearAuthenticationError extends LinearAPIError {
+  constructor(message) {
+    super(message, 401);
+    this.name = "LinearAuthenticationError";
+  }
+}
+
+// src/services/linear.ts
+class LinearService extends Service {
+  static serviceType = "linear";
+  capabilityDescription = "Linear API integration for issue tracking, project management, and team collaboration";
+  client;
+  activityLog = [];
+  linearConfig;
+  workspaceId;
+  constructor(runtime) {
+    super(runtime);
+    const apiKey = runtime?.getSetting("LINEAR_API_KEY");
+    const workspaceId = runtime?.getSetting("LINEAR_WORKSPACE_ID");
+    if (!apiKey) {
+      throw new LinearAuthenticationError("Linear API key is required");
+    }
+    this.linearConfig = {
+      LINEAR_API_KEY: apiKey,
+      LINEAR_WORKSPACE_ID: workspaceId
+    };
+    this.workspaceId = workspaceId;
+    this.client = new LinearClient({
+      apiKey: this.linearConfig.LINEAR_API_KEY
+    });
+  }
+  static async start(runtime) {
+    const service = new LinearService(runtime);
+    await service.validateConnection();
+    logger11.info("Linear service started successfully");
+    return service;
+  }
+  async stop() {
+    this.activityLog = [];
+    logger11.info("Linear service stopped");
+  }
+  async validateConnection() {
+    try {
+      const viewer = await this.client.viewer;
+      logger11.info(`Linear connected as user: ${viewer.email}`);
+    } catch (_error) {
+      throw new LinearAuthenticationError("Failed to authenticate with Linear API");
+    }
+  }
+  logActivity(action, resourceType, resourceId, details, success, error) {
+    const activity = {
+      id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      timestamp: new Date().toISOString(),
+      action,
+      resource_type: resourceType,
+      resource_id: resourceId,
+      details,
+      success,
+      error
+    };
+    this.activityLog.push(activity);
+    if (this.activityLog.length > 1000) {
+      this.activityLog = this.activityLog.slice(-1000);
+    }
+  }
+  getActivityLog(limit, filter) {
+    let filtered = [...this.activityLog];
+    if (filter) {
+      filtered = filtered.filter((item) => {
+        return Object.entries(filter).every(([key, value]) => {
+          return item[key] === value;
+        });
+      });
+    }
+    return filtered.slice(-(limit || 100));
+  }
+  clearActivityLog() {
+    this.activityLog = [];
+    logger11.info("Linear activity log cleared");
+  }
+  async getTeams() {
+    const teams = await this.client.teams();
+    const teamList = await teams.nodes;
+    this.logActivity("list_teams", "team", "all", { count: teamList.length }, true);
+    return teamList;
+  }
+  async getTeam(teamId) {
+    const team = await this.client.team(teamId);
+    this.logActivity("get_team", "team", teamId, { name: team.name }, true);
+    return team;
+  }
+  async createIssue(input) {
+    const issuePayload = await this.client.createIssue({
+      title: input.title,
+      description: input.description,
+      teamId: input.teamId,
+      priority: input.priority,
+      assigneeId: input.assigneeId,
+      labelIds: input.labelIds,
+      projectId: input.projectId,
+      stateId: input.stateId,
+      estimate: input.estimate,
+      dueDate: input.dueDate
+    });
+    const issue = await issuePayload.issue;
+    if (!issue) {
+      throw new Error("Failed to create issue");
+    }
+    this.logActivity("create_issue", "issue", issue.id, {
+      title: input.title,
+      teamId: input.teamId
+    }, true);
+    return issue;
+  }
+  async getIssue(issueId) {
+    const issue = await this.client.issue(issueId);
+    this.logActivity("get_issue", "issue", issueId, {
+      title: issue.title,
+      identifier: issue.identifier
+    }, true);
+    return issue;
+  }
+  async updateIssue(issueId, updates) {
+    const updatePayload = await this.client.updateIssue(issueId, {
+      title: updates.title,
+      description: updates.description,
+      priority: updates.priority,
+      assigneeId: updates.assigneeId,
+      labelIds: updates.labelIds,
+      projectId: updates.projectId,
+      stateId: updates.stateId,
+      estimate: updates.estimate,
+      dueDate: updates.dueDate
+    });
+    const issue = await updatePayload.issue;
+    if (!issue) {
+      throw new Error("Failed to update issue");
+    }
+    this.logActivity("update_issue", "issue", issueId, updates, true);
+    return issue;
+  }
+  async deleteIssue(issueId) {
+    const archivePayload = await this.client.archiveIssue(issueId);
+    const success = await archivePayload.success;
+    if (!success) {
+      throw new Error("Failed to archive issue");
+    }
+    this.logActivity("delete_issue", "issue", issueId, { action: "archived" }, true);
+  }
+  async searchIssues(filters) {
+    const filterObject = {};
+    if (filters.query) {
+      filterObject.or = [
+        { title: { containsIgnoreCase: filters.query } },
+        { description: { containsIgnoreCase: filters.query } }
+      ];
+    }
+    if (filters.team) {
+      const teams = await this.getTeams();
+      const team = teams.find((t) => t.key.toLowerCase() === filters.team?.toLowerCase() || t.name.toLowerCase() === filters.team?.toLowerCase());
+      if (team) {
+        filterObject.team = { id: { eq: team.id } };
+      }
+    }
+    if (filters.assignee && filters.assignee.length > 0) {
+      const users = await this.getUsers();
+      const assigneeIds = filters.assignee.map((assigneeName) => {
+        const user = users.find((u) => u.email === assigneeName || u.name.toLowerCase().includes(assigneeName.toLowerCase()));
+        return user?.id;
+      }).filter(Boolean);
+      if (assigneeIds.length > 0) {
+        filterObject.assignee = { id: { in: assigneeIds } };
+      }
+    }
+    if (filters.priority && filters.priority.length > 0) {
+      filterObject.priority = { number: { in: filters.priority } };
+    }
+    if (filters.state && filters.state.length > 0) {
+      filterObject.state = {
+        name: { in: filters.state }
+      };
+    }
+    if (filters.label && filters.label.length > 0) {
+      filterObject.labels = {
+        some: {
+          name: { in: filters.label }
+        }
+      };
+    }
+    const query = this.client.issues({
+      first: filters.limit || 50,
+      filter: Object.keys(filterObject).length > 0 ? filterObject : undefined
+    });
+    const issues = await query;
+    const issueList = await issues.nodes;
+    this.logActivity("search_issues", "issue", "search", {
+      filters: { ...filters },
+      count: issueList.length
+    }, true);
+    return issueList;
+  }
+  async createComment(input) {
+    const commentPayload = await this.client.createComment({
+      body: input.body,
+      issueId: input.issueId
+    });
+    const comment = await commentPayload.comment;
+    if (!comment) {
+      throw new Error("Failed to create comment");
+    }
+    this.logActivity("create_comment", "comment", comment.id, {
+      issueId: input.issueId,
+      bodyLength: input.body.length
+    }, true);
+    return comment;
+  }
+  async getProjects(teamId) {
+    const query = this.client.projects({
+      first: 100
+    });
+    const projects = await query;
+    let projectList = await projects.nodes;
+    if (teamId) {
+      const filteredProjects = await Promise.all(projectList.map(async (project) => {
+        const projectTeams = await project.teams();
+        const teamsList = await projectTeams.nodes;
+        const hasTeam = teamsList.some((team) => team.id === teamId);
+        return hasTeam ? project : null;
+      }));
+      projectList = filteredProjects.filter(Boolean);
+    }
+    this.logActivity("list_projects", "project", "all", {
+      count: projectList.length,
+      teamId
+    }, true);
+    return projectList;
+  }
+  async getProject(projectId) {
+    const project = await this.client.project(projectId);
+    this.logActivity("get_project", "project", projectId, {
+      name: project.name
+    }, true);
+    return project;
+  }
+  async getUsers() {
+    const users = await this.client.users();
+    const userList = await users.nodes;
+    this.logActivity("list_users", "user", "all", {
+      count: userList.length
+    }, true);
+    return userList;
+  }
+  async getCurrentUser() {
+    const user = await this.client.viewer;
+    this.logActivity("get_current_user", "user", user.id, {
+      email: user.email,
+      name: user.name
+    }, true);
+    return user;
+  }
+  async getUserTeams() {
+    const viewer = await this.client.viewer;
+    const teams = await viewer.teams();
+    const teamList = await teams.nodes;
+    this.logActivity("list_user_teams", "team", viewer.id, {
+      count: teamList.length
+    }, true);
+    return teamList;
+  }
+  async getLabels(teamId) {
+    const query = this.client.issueLabels({
+      first: 100,
+      filter: teamId ? {
+        team: { id: { eq: teamId } }
+      } : undefined
+    });
+    const labels = await query;
+    const labelList = await labels.nodes;
+    this.logActivity("list_labels", "label", "all", {
+      count: labelList.length,
+      teamId
+    }, true);
+    return labelList;
+  }
+  async getWorkflowStates(teamId) {
+    const states = await this.client.workflowStates({
+      filter: {
+        team: { id: { eq: teamId } }
+      }
+    });
+    const stateList = await states.nodes;
+    this.logActivity("list_workflow_states", "team", teamId, {
+      count: stateList.length
+    }, true);
+    return stateList;
+  }
+}
+
 // src/index.ts
 var linearPlugin = {
-  name: "@elizaos/plugin-linear",
+  name: "@elizaos/plugin-linear-ts",
   description: "Plugin for integrating with Linear issue tracking system",
   services: [LinearService],
   actions: [
@@ -2666,17 +2819,15 @@ var linearPlugin = {
     clearActivityAction
   ],
   providers: [
-    // linearIssuesProvider,
-    // linearTeamsProvider,
-    // linearProjectsProvider,
-    // linearActivityProvider,
+    linearIssuesProvider,
+    linearTeamsProvider,
+    linearProjectsProvider,
+    linearActivityProvider
   ]
 };
 export {
-  LinearAPIError,
-  LinearAuthenticationError,
-  LinearRateLimitError,
-  LinearService,
-  linearPlugin
+  linearPlugin,
+  LinearService
 };
-//# sourceMappingURL=index.js.map
+
+//# debugId=AB1E47AE7B755C0964756E2164756E21