@elizaos/plugin-linear 1.2.11 → 1.2.12

package/dist/index.js

@@ -195,16 +195,68 @@ var _LinearService = class _LinearService extends Service {
       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");
+      }
+      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) {
     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 query = this.client.issues({
         first: filters.limit || 50,
-        filter: filters.query ? {
-          or: [
-            { title: { containsIgnoreCase: filters.query } },
-            { description: { containsIgnoreCase: filters.query } }
-          ]
-        } : void 0
+        filter: Object.keys(filterObject).length > 0 ? filterObject : void 0
       });
       const issues = await query;
       const issueList = await issues.nodes;
@@ -593,11 +645,37 @@ View it at: ${issue.url}`;
 };
 
 // src/actions/getIssue.ts
-import { logger as logger3 } from "@elizaos/core";
+import { logger as logger3, ModelType as ModelType2 } from "@elizaos/core";
+var getIssueTemplate = `Extract issue identification from the user's request.
+
+User request: "{{userMessage}}"
+
+The user might reference an issue by:
+- Direct ID (e.g., "ENG-123", "COM2-7")
+- Title keywords (e.g., "the login bug", "that payment issue")
+- Assignee (e.g., "John's high priority task")
+- Recency (e.g., "the latest bug", "most recent issue")
+- Team context (e.g., "newest issue in ELIZA team")
+
+Return ONLY a JSON object:
+{
+  "directId": "Issue ID if explicitly mentioned (e.g., ENG-123)",
+  "searchBy": {
+    "title": "Keywords from issue title if mentioned",
+    "assignee": "Name/email of assignee if mentioned", 
+    "priority": "Priority level if mentioned (urgent/high/normal/low or 1-4)",
+    "team": "Team name or key if mentioned",
+    "state": "Issue state if mentioned (todo/in-progress/done)",
+    "recency": "latest/newest/recent/last if mentioned",
+    "type": "bug/feature/task if mentioned"
+  }
+}
+
+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"],
+  similes: ["get-linear-issue", "show-linear-issue", "view-linear-issue", "check-linear-issue", "find-linear-issue"],
   examples: [[
     {
       name: "User",
@@ -616,13 +694,27 @@ var getIssueAction = {
     {
       name: "User",
       content: {
-        text: "What's the status of BUG-456?"
+        text: "What's the status of the login bug?"
       }
     },
     {
       name: "Assistant",
       content: {
-        text: "Let me check the status of BUG-456 for you.",
+        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"]
       }
     }
@@ -643,102 +735,133 @@ var getIssueAction = {
       }
       const content = message.content.text;
       if (!content) {
-        const errorMessage = "Please specify an issue ID.";
+        const errorMessage2 = "Please specify which issue you want to see.";
         await callback?.({
-          text: errorMessage,
+          text: errorMessage2,
           source: message.content.source
         });
         return {
-          text: errorMessage,
+          text: errorMessage2,
           success: false
         };
       }
-      const issueMatch = content.match(/(\w+-\d+)/);
-      if (!issueMatch) {
-        const errorMessage = "Please provide a valid issue ID (e.g., ENG-123).";
-        await callback?.({
-          text: errorMessage,
-          source: message.content.source
-        });
-        return {
-          text: errorMessage,
-          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");
       }
-      const issueId = issueMatch[1];
-      const issue = await linearService.getIssue(issueId);
-      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
-        } : null
-      };
-      let responseText = `\u{1F4CB} Issue ${issue.identifier}: ${issue.title}
-`;
-      responseText += `Status: ${state?.name || "Unknown"}
-`;
-      responseText += `Priority: ${issue.priorityLabel}
-`;
-      if (assignee) {
-        responseText += `Assignee: ${assignee.name}
-`;
-      }
-      if (issue.dueDate) {
-        responseText += `Due: ${new Date(issue.dueDate).toLocaleDateString()}
-`;
-      }
-      if (issue.description) {
-        responseText += `
-Description: ${issue.description}
-`;
-      }
-      responseText += `
-View in Linear: ${issue.url}`;
+      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")}
+
+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: responseText,
+        text: errorMessage,
         source: message.content.source
       });
       return {
-        text: responseText,
-        success: true,
-        data: issueDetails
+        text: errorMessage,
+        success: false
       };
     } catch (error) {
       logger3.error("Failed to get issue:", error);
@@ -754,9 +877,80 @@ View in Linear: ${issue.url}`;
     }
   }
 };
+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}` : ""}
+
+${issue.description || "No description"}
+
+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 }
+  };
+}
 
 // src/actions/updateIssue.ts
-import { logger as logger4, ModelType as ModelType2 } from "@elizaos/core";
+import { logger as logger4, ModelType as ModelType3 } from "@elizaos/core";
 var updateIssueTemplate = `Given the user's request to update a Linear issue, extract the information needed.
 
 User request: "{{userMessage}}"
@@ -850,7 +1044,7 @@ var updateIssueAction = {
         };
       }
       const prompt = updateIssueTemplate.replace("{{userMessage}}", content);
-      const response = await runtime.useModel(ModelType2.TEXT_LARGE, {
+      const response = await runtime.useModel(ModelType3.TEXT_LARGE, {
         prompt
       });
       if (!response) {
@@ -1018,32 +1212,209 @@ 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.`;
+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"]
+      }
+    }
+  ], [
+    {
+      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"]
+      }
+    }
+  ]],
+  async validate(runtime, _message, _state) {
+    try {
+      const apiKey = runtime.getSetting("LINEAR_API_KEY");
+      return !!apiKey;
+    } catch {
+      return false;
+    }
+  },
+  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 specify which issue to delete.";
+        await callback?.({
+          text: errorMessage,
+          source: message.content.source
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      let issueId;
+      if (_options?.issueId) {
+        issueId = _options.issueId;
+      } else {
+        const prompt = deleteIssueTemplate.replace("{{userMessage}}", content);
+        const response = await runtime.useModel(ModelType4.TEXT_LARGE, {
+          prompt
+        });
+        if (!response) {
+          throw new Error("Failed to extract issue identifier");
+        }
+        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");
+          }
+        } catch (parseError) {
+          logger5.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.";
+            await callback?.({
+              text: errorMessage,
+              source: message.content.source
+            });
+            return {
+              text: errorMessage,
+              success: false
+            };
+          }
+          issueId = issueMatch[1];
+        }
+      }
+      const issue = await linearService.getIssue(issueId);
+      const issueTitle = issue.title;
+      const issueIdentifier = issue.identifier;
+      logger5.info(`Archiving issue ${issueIdentifier}: ${issueTitle}`);
+      await linearService.deleteIssue(issueId);
+      const successMessage = `\u2705 Successfully archived issue ${issueIdentifier}: "${issueTitle}"
+
+The issue has been moved to the archived state and will no longer appear in active views.`;
+      await callback?.({
+        text: successMessage,
+        source: message.content.source
+      });
+      return {
+        text: `Archived issue ${issueIdentifier}: "${issueTitle}"`,
+        success: true,
+        data: {
+          issueId: issue.id,
+          identifier: issueIdentifier,
+          title: issueTitle,
+          archived: true
+        }
+      };
+    } catch (error) {
+      logger5.error("Failed to delete issue:", error);
+      const errorMessage = `\u274C Failed to delete issue: ${error instanceof Error ? error.message : "Unknown error"}`;
+      await callback?.({
+        text: errorMessage,
+        source: message.content.source
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+  }
+};
+
 // src/actions/searchIssues.ts
 import {
-  ModelType as ModelType3,
-  logger as logger5
+  ModelType as ModelType5,
+  logger as logger6
 } from "@elizaos/core";
 var searchTemplate = `Extract search criteria from the user's request for Linear issues.
 
 User request: "{{userMessage}}"
 
-Extract and return ONLY a JSON object (no markdown formatting, no code blocks) with these possible filters:
+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",
-  "state": "filter by state name (e.g., 'In Progress', 'Done', 'Todo')",
-  "assignee": "filter by assignee name or email",
-  "priority": "filter by priority (1=urgent, 2=high, 3=normal, 4=low)",
-  "team": "filter by team name or key",
-  "label": "filter by label name",
-  "hasAssignee": true/false - whether issue should have an assignee,
-  "limit": number of results to return (default 10)
+  "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 mentioned. Return only the JSON object.`;
+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"],
+  similes: ["search-linear-issues", "find-linear-issues", "query-linear-issues", "list-linear-issues"],
   examples: [[
     {
       name: "User",
@@ -1062,13 +1433,27 @@ var searchIssuesAction = {
     {
       name: "User",
       content: {
-        text: "Find high priority issues assigned to me"
+        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 high priority issues created this week"
       }
     },
     {
       name: "Assistant",
       content: {
-        text: "I'll search for high priority issues assigned to you.",
+        text: "I'll search for high priority issues created this week.",
         actions: ["SEARCH_LINEAR_ISSUES"]
       }
     }
@@ -1104,7 +1489,7 @@ var searchIssuesAction = {
         filters = _options.filters;
       } else {
         const prompt = searchTemplate.replace("{{userMessage}}", content);
-        const response = await runtime.useModel(ModelType3.TEXT_LARGE, {
+        const response = await runtime.useModel(ModelType5.TEXT_LARGE, {
           prompt
         });
         if (!response) {
@@ -1115,25 +1500,79 @@ var searchIssuesAction = {
             const parsed = JSON.parse(cleanedResponse);
             filters = {
               query: parsed.query,
-              state: parsed.state ? [parsed.state] : void 0,
-              assignee: parsed.assignee ? [parsed.assignee] : void 0,
-              priority: parsed.priority ? [parsed.priority] : void 0,
-              team: parsed.team,
-              label: parsed.label ? [parsed.label] : void 0,
-              limit: parsed.limit
+              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);
+                }
+              }
+              if (processedAssignees.length > 0) {
+                filters.assignee = processedAssignees;
+              }
+            }
+            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.teams && parsed.teams.length > 0) {
+              filters.team = parsed.teams[0];
+            }
+            if (parsed.labels && parsed.labels.length > 0) {
+              filters.label = parsed.labels;
+            }
+            if (parsed.dateRange || parsed.sort) {
+              logger6.info("Date range and sort filters noted but not yet implemented");
+            }
             Object.keys(filters).forEach((key) => {
               if (filters[key] === void 0) {
                 delete filters[key];
               }
             });
           } catch (parseError) {
-            logger5.error("Failed to parse search filters:", parseError);
+            logger6.error("Failed to parse search filters:", parseError);
             filters = { query: content };
           }
         }
       }
-      filters.limit = _options?.limit || 10;
+      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}`);
+          }
+        }
+      }
+      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.";
@@ -1153,37 +1592,47 @@ var searchIssuesAction = {
       }
       const issueList = await Promise.all(issues.map(async (issue, index) => {
         const state = await issue.state;
-        return `${index + 1}. ${issue.identifier}: ${issue.title} (${state?.name || "No 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");
+      const issueText = issueList.join("\n\n");
       const resultMessage = `\u{1F4CB} Found ${issues.length} issue${issues.length === 1 ? "" : "s"}:
+
 ${issueText}`;
       await callback?.({
         text: resultMessage,
         source: message.content.source
       });
       return {
-        text: `Found ${issues.length} issue${issues.length === 1 ? "" : "s"}:
-${issueText}`,
+        text: `Found ${issues.length} issue${issues.length === 1 ? "" : "s"}`,
         success: true,
         data: {
-          issues: issues.map((i) => ({
-            id: i.id,
-            identifier: i.identifier,
-            title: i.title,
-            description: i.description,
-            url: i.url,
-            state: i.state,
-            priority: i.priority,
-            priorityLabel: i.priorityLabel,
-            assignee: i.assignee
+          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,
+              updatedAt: issue.updatedAt
+            };
           })),
           filters,
           count: issues.length
         }
       };
     } catch (error) {
-      logger5.error("Failed to search issues:", error);
+      logger6.error("Failed to search issues:", error);
       const errorMessage = `\u274C Failed to search issues: ${error instanceof Error ? error.message : "Unknown error"}`;
       await callback?.({
         text: errorMessage,
@@ -1198,22 +1647,56 @@ ${issueText}`,
 };
 
 // src/actions/createComment.ts
-import { logger as logger6 } from "@elizaos/core";
+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"
+
+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 createCommentAction = {
   name: "CREATE_LINEAR_COMMENT",
-  description: "Create a comment on a Linear issue",
-  similes: ["create-linear-comment", "add-linear-comment", "comment-on-linear-issue"],
+  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 has been fixed in the latest release"
+        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: "Tell the login bug that we need more information from QA"
       }
     },
     {
       name: "Assistant",
       content: {
-        text: "I'll add that comment to issue ENG-123.",
+        text: "I'll add that comment to the login bug issue.",
         actions: ["CREATE_LINEAR_COMMENT"]
       }
     }
@@ -1221,13 +1704,13 @@ var createCommentAction = {
     {
       name: "User",
       content: {
-        text: "Add a comment to BUG-456: Need more information from the reporter"
+        text: "Reply to COM2-7: Thanks for the update, I'll look into it"
       }
     },
     {
       name: "Assistant",
       content: {
-        text: "I'll post that comment on BUG-456 right away.",
+        text: "I'll add your reply to issue COM2-7.",
         actions: ["CREATE_LINEAR_COMMENT"]
       }
     }
@@ -1248,7 +1731,7 @@ var createCommentAction = {
       }
       const content = message.content.text;
       if (!content) {
-        const errorMessage = "Please provide a message with the issue ID and comment content.";
+        const errorMessage = "Please provide a message with the issue and comment content.";
         await callback?.({
           text: errorMessage,
           source: message.content.source
@@ -1258,9 +1741,108 @@ var createCommentAction = {
           success: false
         };
       }
-      const issueMatch = content.match(/(?:comment on|add.*comment.*to)\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"';
+      let issueId;
+      let commentBody;
+      if (_options?.issueId && _options?.body) {
+        issueId = _options.issueId;
+        commentBody = _options.body;
+      } else {
+        const prompt = createCommentTemplate.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 {
+          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
+                  }
+                };
+              }
+            } else {
+              throw new Error("No issue identifier or description found");
+            }
+            if (parsed.commentType && parsed.commentType !== "note") {
+              commentBody = `[${parsed.commentType.toUpperCase()}] ${commentBody}`;
+            }
+          } 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
+              };
+            }
+            issueId = issueMatch[1];
+            commentBody = issueMatch[2].trim();
+          }
+        }
+      }
+      if (!commentBody || commentBody.length === 0) {
+        const errorMessage = "Please provide the comment content.";
         await callback?.({
           text: errorMessage,
           source: message.content.source
@@ -1270,27 +1852,29 @@ var createCommentAction = {
           success: false
         };
       }
-      const [, issueIdentifier, commentBody] = issueMatch;
-      const issue = await linearService.getIssue(issueIdentifier);
+      const issue = await linearService.getIssue(issueId);
       const comment = await linearService.createComment({
         issueId: issue.id,
-        body: commentBody.trim()
+        body: commentBody
       });
-      const successMessage = `\u2705 Comment added to issue ${issueIdentifier}: "${commentBody.trim()}"`;
+      const successMessage = `\u2705 Comment added to issue ${issue.identifier}: "${commentBody}"`;
       await callback?.({
         text: successMessage,
         source: message.content.source
       });
       return {
-        text: `Comment added to issue ${issueIdentifier}: "${commentBody.trim()}"`,
+        text: `Added comment to issue ${issue.identifier}`,
         success: true,
         data: {
           commentId: comment.id,
-          issueId: issue.id
+          issueId: issue.id,
+          issueIdentifier: issue.identifier,
+          commentBody,
+          createdAt: comment.createdAt
         }
       };
     } catch (error) {
-      logger6.error("Failed to create comment:", error);
+      logger7.error("Failed to create comment:", error);
       const errorMessage = `\u274C Failed to create comment: ${error instanceof Error ? error.message : "Unknown error"}`;
       await callback?.({
         text: errorMessage,
@@ -1305,11 +1889,34 @@ var createCommentAction = {
 };
 
 // src/actions/listTeams.ts
-import { logger as logger7 } from "@elizaos/core";
+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.`;
 var listTeamsAction = {
   name: "LIST_LINEAR_TEAMS",
-  description: "List all teams in Linear",
-  similes: ["list-linear-teams", "show-linear-teams", "get-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",
@@ -1328,13 +1935,27 @@ var listTeamsAction = {
     {
       name: "User",
       content: {
-        text: "What teams are available?"
+        text: "Which engineering teams do we have?"
       }
     },
     {
       name: "Assistant",
       content: {
-        text: "Let me show you all the available teams.",
+        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"]
       }
     }
@@ -1353,9 +1974,51 @@ var listTeamsAction = {
       if (!linearService) {
         throw new Error("Linear service not available");
       }
-      const teams = await linearService.getTeams();
+      const content = message.content.text || "";
+      let nameFilter;
+      let specificTeam;
+      let myTeams = false;
+      let includeDetails = false;
+      if (content) {
+        const prompt = listTeamsTemplate.replace("{{userMessage}}", content);
+        const response = await runtime.useModel(ModelType7.TEXT_LARGE, {
+          prompt
+        });
+        if (response) {
+          try {
+            const parsed = JSON.parse(response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim());
+            nameFilter = parsed.nameFilter;
+            specificTeam = parsed.specificTeam;
+            myTeams = parsed.myTeams === true;
+            includeDetails = parsed.includeDetails === true;
+          } catch (parseError) {
+            logger8.warn("Failed to parse team filters:", parseError);
+          }
+        }
+      }
+      let teams = await linearService.getTeams();
+      if (specificTeam) {
+        teams = teams.filter(
+          (team) => team.key.toLowerCase() === specificTeam.toLowerCase() || team.name.toLowerCase() === specificTeam.toLowerCase()
+        );
+      }
+      if (nameFilter && !specificTeam) {
+        const keywords = nameFilter.toLowerCase().split(/\s+/);
+        teams = teams.filter((team) => {
+          const teamText = `${team.name} ${team.description || ""}`.toLowerCase();
+          return keywords.some((keyword) => teamText.includes(keyword));
+        });
+      }
+      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");
+        }
+      }
       if (teams.length === 0) {
-        const noTeamsMessage = "No teams found in Linear.";
+        const noTeamsMessage = specificTeam ? `No team found matching "${specificTeam}".` : nameFilter ? `No teams found matching "${nameFilter}".` : "No teams found in Linear.";
         await callback?.({
           text: noTeamsMessage,
           source: message.content.source
@@ -1368,31 +2031,68 @@ var listTeamsAction = {
           }
         };
       }
-      const teamList = teams.map(
-        (team, index) => `${index + 1}. ${team.name} (${team.key})${team.description ? ` - ${team.description}` : ""}`
-      ).join("\n");
-      const resultMessage = `\u{1F465} Found ${teams.length} team${teams.length === 1 ? "" : "s"}:
+      let teamsWithDetails = teams;
+      if (includeDetails || specificTeam) {
+        teamsWithDetails = await Promise.all(teams.map(async (team) => {
+          const membersQuery = await team.members();
+          const members = await membersQuery.nodes;
+          const projectsQuery = await team.projects();
+          const projects = await projectsQuery.nodes;
+          return {
+            ...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) => {
+        let info = `${index + 1}. ${team.name} (${team.key})`;
+        if (team.description) {
+          info += `
+   ${team.description}`;
+        }
+        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(", ");
+            info += `
+   Team members: ${memberNames}${team.memberCount > 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"}:`;
+      const resultMessage = `${headerText}
+
 ${teamList}`;
       await callback?.({
         text: resultMessage,
         source: message.content.source
       });
       return {
-        text: `Found ${teams.length} team${teams.length === 1 ? "" : "s"}:
-${teamList}`,
+        text: `Found ${teams.length} team${teams.length === 1 ? "" : "s"}`,
         success: true,
         data: {
-          teams: teams.map((t) => ({
+          teams: teamsWithDetails.map((t) => ({
             id: t.id,
             name: t.name,
             key: t.key,
-            description: t.description
+            description: t.description,
+            memberCount: t.memberCount,
+            projectCount: t.projectCount
           })),
-          count: teams.length
+          count: teams.length,
+          filters: {
+            name: nameFilter,
+            specific: specificTeam
+          }
         }
       };
     } catch (error) {
-      logger7.error("Failed to list teams:", error);
+      logger8.error("Failed to list teams:", error);
       const errorMessage = `\u274C Failed to list teams: ${error instanceof Error ? error.message : "Unknown error"}`;
       await callback?.({
         text: errorMessage,
@@ -1407,11 +2107,40 @@ ${teamList}`,
 };
 
 // src/actions/listProjects.ts
-import { logger as logger8 } from "@elizaos/core";
+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 all projects in Linear",
-  similes: ["list-linear-projects", "show-linear-projects", "get-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",
@@ -1430,13 +2159,27 @@ var listProjectsAction = {
     {
       name: "User",
       content: {
-        text: "What projects do we have?"
+        text: "What active projects do we have?"
       }
     },
     {
       name: "Assistant",
       content: {
-        text: "Let me show you all the available projects.",
+        text: "Let me show you all the active projects.",
+        actions: ["LIST_LINEAR_PROJECTS"]
+      }
+    }
+  ], [
+    {
+      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"]
       }
     }
@@ -1455,9 +2198,79 @@ var listProjectsAction = {
       if (!linearService) {
         throw new Error("Linear service not available");
       }
-      const projects = await linearService.getProjects();
+      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(ModelType8.TEXT_LARGE, {
+          prompt
+        });
+        if (response) {
+          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})`);
+              }
+            }
+            showAll = parsed.showAll === true;
+            stateFilter = parsed.stateFilter;
+            if (parsed.dateFilter || parsed.leadFilter) {
+              logger9.info("Date and lead filters noted but not yet implemented");
+            }
+          } 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})`);
+              }
+            }
+            showAll = content.toLowerCase().includes("all") && content.toLowerCase().includes("project");
+          }
+        }
+      }
+      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;
+            logger9.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 = "No projects found in Linear.";
+        const noProjectsMessage = teamId ? "No projects found for the specified team." : "No projects found in Linear.";
         await callback?.({
           text: noProjectsMessage,
           source: message.content.source
@@ -1474,25 +2287,37 @@ var listProjectsAction = {
         projects.map(async (project) => {
           const teamsQuery = await project.teams();
           const teams = await teamsQuery.nodes;
+          const lead = await project.lead;
           return {
             ...project,
-            teamsList: teams
+            teamsList: teams,
+            leadUser: lead
           };
         })
       );
       const projectList = projectsWithDetails.map((project, index) => {
         const teamNames = project.teamsList.map((t) => t.name).join(", ") || "No teams";
-        return `${index + 1}. ${project.name}${project.description ? ` - ${project.description}` : ""} (Teams: ${teamNames})`;
-      }).join("\n");
-      const resultMessage = `\u{1F4C1} Found ${projects.length} project${projects.length === 1 ? "" : "s"}:
+        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}
+
 ${projectList}`;
       await callback?.({
         text: resultMessage,
         source: message.content.source
       });
       return {
-        text: `Found ${projects.length} project${projects.length === 1 ? "" : "s"}:
-${projectList}`,
+        text: `Found ${projects.length} project${projects.length === 1 ? "" : "s"}`,
         success: true,
         data: {
           projects: projectsWithDetails.map((p) => ({
@@ -1505,16 +2330,25 @@ ${projectList}`,
               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
+          count: projects.length,
+          filters: {
+            team: teamId,
+            state: stateFilter
+          }
         }
       };
     } catch (error) {
-      logger8.error("Failed to list projects:", error);
+      logger9.error("Failed to list projects:", error);
       const errorMessage = `\u274C Failed to list projects: ${error instanceof Error ? error.message : "Unknown error"}`;
       await callback?.({
         text: errorMessage,
@@ -1529,11 +2363,39 @@ ${projectList}`,
 };
 
 // src/actions/getActivity.ts
-import { logger as logger9 } from "@elizaos/core";
+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",
-  similes: ["get-linear-activity", "show-linear-activity", "view-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",
@@ -1544,7 +2406,21 @@ var getActivityAction = {
     {
       name: "Assistant",
       content: {
-        text: "I'll check the recent Linear activity for you.",
+        text: "I'll show you the recent Linear activity.",
+        actions: ["GET_LINEAR_ACTIVITY"]
+      }
+    }
+  ], [
+    {
+      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"]
       }
     }
@@ -1552,13 +2428,13 @@ var getActivityAction = {
     {
       name: "User",
       content: {
-        text: "What's been happening in Linear?"
+        text: "Show me what issues John created this week"
       }
     },
     {
       name: "Assistant",
       content: {
-        text: "Let me show you the recent Linear activity.",
+        text: "I'll find the issues John created this week.",
         actions: ["GET_LINEAR_ACTIVITY"]
       }
     }
@@ -1577,9 +2453,74 @@ var getActivityAction = {
       if (!linearService) {
         throw new Error("Linear service not available");
       }
-      const activity = linearService.getActivityLog();
+      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
+        });
+        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;
+            }
+            if (parsed.successFilter && parsed.successFilter !== "all") {
+              filters.success = parsed.successFilter === "success";
+            }
+            limit = parsed.limit || 10;
+          } catch (parseError) {
+            logger10.warn("Failed to parse activity filters:", parseError);
+          }
+        }
+      }
+      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 = "No recent Linear activity found.";
+        const noActivityMessage = filters.fromDate ? `No Linear activity found for the specified filters.` : "No recent Linear activity found.";
         await callback?.({
           text: noActivityMessage,
           source: message.content.source
@@ -1592,28 +2533,35 @@ var getActivityAction = {
           }
         };
       }
-      const activityText = activity.slice(0, 10).map((item, index) => {
-        const description = `${item.action} ${item.resource_type} ${item.resource_id}${item.error ? ` (failed: ${item.error})` : ""}`;
-        return `${index + 1}. ${description}`;
-      }).join("\n");
-      const resultMessage = `\u{1F4CA} Recent Linear activity:
+      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}
+
 ${activityText}`;
       await callback?.({
         text: resultMessage,
         source: message.content.source
       });
       return {
-        text: `Recent Linear activity:
-${activityText}`,
+        text: `Found ${activity.length} activity item${activity.length === 1 ? "" : "s"}`,
         success: true,
         data: {
-          activity: activity.slice(0, 10),
+          activity,
+          filters,
           count: activity.length
         }
       };
     } catch (error) {
-      logger9.error("Failed to get Linear activity:", error);
-      const errorMessage = `\u274C Failed to get Linear activity: ${error instanceof Error ? error.message : "Unknown error"}`;
+      logger10.error("Failed to get activity:", error);
+      const errorMessage = `\u274C Failed to get activity: ${error instanceof Error ? error.message : "Unknown error"}`;
       await callback?.({
         text: errorMessage,
         source: message.content.source
@@ -1627,7 +2575,7 @@ ${activityText}`,
 };
 
 // src/actions/clearActivity.ts
-import { logger as logger10 } from "@elizaos/core";
+import { logger as logger11 } from "@elizaos/core";
 var clearActivityAction = {
   name: "CLEAR_LINEAR_ACTIVITY",
   description: "Clear the Linear activity log",
@@ -1686,7 +2634,7 @@ var clearActivityAction = {
         success: true
       };
     } catch (error) {
-      logger10.error("Failed to clear Linear activity:", 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,
@@ -1709,6 +2657,7 @@ var linearPlugin = {
     createIssueAction,
     getIssueAction,
     updateIssueAction,
+    deleteIssueAction,
     searchIssuesAction,
     createCommentAction,
     listTeamsAction,