@elizaos/plugin-linear 2.0.0-alpha.6 → 2.0.0-beta.1

package/dist/index.js

@@ -1,11 +1,173 @@
+// src/index.ts
+import { getConnectorAccountManager, logger as logger14, promoteSubactionsToActions } from "@elizaos/core";
+
+// src/accounts.ts
+var DEFAULT_LINEAR_ACCOUNT_ID = "default";
+var DEFAULT_LINEAR_ACCOUNT_ROLE = "OWNER";
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function readSetting(runtime, key) {
+  return nonEmptyString(runtime.getSetting(key));
+}
+function normalizeLinearAccountId(value) {
+  return nonEmptyString(value) ?? DEFAULT_LINEAR_ACCOUNT_ID;
+}
+function resolveLinearAccountId(runtime, options) {
+  const requested = nonEmptyString(options?.accountId) ?? nonEmptyString(options?.linearAccountId);
+  if (requested)
+    return requested;
+  const configuredDefault = readSetting(runtime, "LINEAR_DEFAULT_ACCOUNT_ID") ?? readSetting(runtime, "LINEAR_ACCOUNT_ID");
+  const accounts = readLinearAccounts(runtime);
+  const defaultAccount = resolveLinearDefaultAccount(accounts, configuredDefault);
+  return defaultAccount?.accountId ?? normalizeLinearAccountId(configuredDefault);
+}
+function parseAccountsJson(raw) {
+  if (!raw)
+    return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) {
+      return parsed.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item));
+    }
+    if (parsed && typeof parsed === "object") {
+      return Object.entries(parsed).filter(([, value]) => value && typeof value === "object").map(([id, value]) => ({
+        ...value,
+        accountId: value.accountId ?? id
+      }));
+    }
+  } catch {
+    return [];
+  }
+  return [];
+}
+function readRawField(record, keys) {
+  const credentials = record.credentials && typeof record.credentials === "object" ? record.credentials : {};
+  const metadata = record.metadata && typeof record.metadata === "object" ? record.metadata : {};
+  const settings = record.settings && typeof record.settings === "object" ? record.settings : {};
+  for (const source of [record, credentials, metadata, settings]) {
+    for (const key of keys) {
+      const value = nonEmptyString(source[key]);
+      if (value)
+        return value;
+    }
+  }
+  return;
+}
+function accountFromRecord(record) {
+  const accountId = normalizeLinearAccountId(record.accountId ?? record.id ?? record.name);
+  const apiKey = readRawField(record, [
+    "LINEAR_API_KEY",
+    "apiKey",
+    "token",
+    "accessToken",
+    "access"
+  ]);
+  if (!apiKey)
+    return null;
+  return {
+    accountId,
+    role: DEFAULT_LINEAR_ACCOUNT_ROLE,
+    apiKey,
+    workspaceId: readRawField(record, ["LINEAR_WORKSPACE_ID", "workspaceId"]),
+    defaultTeamKey: readRawField(record, ["LINEAR_DEFAULT_TEAM_KEY", "defaultTeamKey"]),
+    label: nonEmptyString(record.label ?? record.displayName)
+  };
+}
+function addAccount(accounts, account) {
+  if (account) {
+    accounts.set(account.accountId, account);
+  }
+}
+function readLinearAccounts(runtime) {
+  const accounts = new Map;
+  const characterConfig = runtime.character?.settings?.linear;
+  const characterAccounts = characterConfig?.accounts;
+  if (Array.isArray(characterAccounts)) {
+    for (const item of characterAccounts) {
+      if (item && typeof item === "object") {
+        addAccount(accounts, accountFromRecord(item));
+      }
+    }
+  } else if (characterAccounts && typeof characterAccounts === "object") {
+    for (const [id, value] of Object.entries(characterAccounts)) {
+      if (value && typeof value === "object") {
+        addAccount(accounts, accountFromRecord({
+          ...value,
+          accountId: value.accountId ?? id
+        }));
+      }
+    }
+  }
+  for (const record of parseAccountsJson(readSetting(runtime, "LINEAR_ACCOUNTS"))) {
+    addAccount(accounts, accountFromRecord(record));
+  }
+  const apiKey = readSetting(runtime, "LINEAR_API_KEY");
+  if (apiKey) {
+    addAccount(accounts, {
+      accountId: normalizeLinearAccountId(readSetting(runtime, "LINEAR_ACCOUNT_ID") ?? readSetting(runtime, "LINEAR_DEFAULT_ACCOUNT_ID")),
+      role: DEFAULT_LINEAR_ACCOUNT_ROLE,
+      apiKey,
+      workspaceId: readSetting(runtime, "LINEAR_WORKSPACE_ID"),
+      defaultTeamKey: readSetting(runtime, "LINEAR_DEFAULT_TEAM_KEY")
+    });
+  }
+  return Array.from(accounts.values());
+}
+function resolveLinearAccount(accounts, accountId) {
+  return accounts.find((account) => account.accountId === accountId) ?? null;
+}
+function resolveLinearDefaultAccount(accounts, accountId) {
+  const normalized = normalizeLinearAccountId(accountId);
+  return resolveLinearAccount(accounts, normalized) ?? resolveLinearAccount(accounts, DEFAULT_LINEAR_ACCOUNT_ID) ?? accounts.find((account) => account.role === DEFAULT_LINEAR_ACCOUNT_ROLE) ?? accounts[0] ?? null;
+}
+function hasLinearAccountConfig(runtime, options) {
+  const accountId = resolveLinearAccountId(runtime, options);
+  return Boolean(resolveLinearAccount(readLinearAccounts(runtime), accountId));
+}
+
+// src/actions/account-options.ts
+function getLinearActionOptions(options) {
+  const direct = options ?? {};
+  const parameters = direct.parameters && typeof direct.parameters === "object" ? direct.parameters : {};
+  return { ...direct, ...parameters };
+}
+function getLinearAccountId(runtime, options) {
+  return resolveLinearAccountId(runtime, getLinearActionOptions(options));
+}
+var linearAccountIdParameter = {
+  name: "accountId",
+  description: "Optional Linear account id from LINEAR_ACCOUNTS. Defaults to LINEAR_DEFAULT_ACCOUNT_ID or the legacy single API key.",
+  required: false,
+  schema: { type: "string" }
+};
+
 // src/actions/clearActivity.ts
 import {
-  logger
+  logger,
+  requireConfirmation
 } from "@elizaos/core";
+
+// src/actions/validate-linear-intent.ts
+async function validateLinearActionIntent(runtime, _message, _state, _spec) {
+  try {
+    return hasLinearAccountConfig(runtime);
+  } catch {
+    return false;
+  }
+}
+
+// src/actions/clearActivity.ts
+var CLEAR_ACTIVITY_TIMEOUT_MS = 1e4;
 var clearActivityAction = {
   name: "CLEAR_LINEAR_ACTIVITY",
-  description: "Clear the Linear activity log",
+  contexts: ["tasks", "connectors", "automation"],
+  contextGate: { anyOf: ["tasks", "connectors", "automation"] },
+  roleGate: { minRole: "USER" },
+  description: "Clear the cached Linear activity log for the connected Linear account. Use when the user asks to reset, wipe, or refresh their Linear activity history before pulling a fresh view of recent issue and comment events.",
+  descriptionCompressed: "clear Linear activity log",
   similes: ["clear-linear-activity", "reset-linear-activity", "delete-linear-activity"],
+  parameters: [linearAccountIdParameter],
   examples: [
     [
       {
@@ -38,38 +200,45 @@ var clearActivityAction = {
       }
     ]
   ],
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["clear", "linear", "activity"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegex = /\b(?:clear|linear|activity)\b/i;
-    const __avRegexOk = __avRegex.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const apiKey = runtime2.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
+  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
+    keywords: ["clear", "linear", "activity"],
+    regexAlternation: "clear|linear|activity"
+  }),
   async handler(runtime, message, _state, _options, callback) {
     try {
       const linearService = runtime.getService("linear");
       if (!linearService) {
         throw new Error("Linear service not available");
       }
-      await linearService.clearActivityLog();
+      const accountId = getLinearAccountId(runtime, _options);
+      const decision = await requireConfirmation({
+        runtime,
+        message,
+        actionName: "CLEAR_LINEAR_ACTIVITY",
+        pendingKey: `clear_log:${accountId}`,
+        prompt: 'Clear the Linear activity log? Reply "yes" to confirm.',
+        callback
+      });
+      if (decision.status === "pending") {
+        return {
+          text: "Awaiting confirmation to clear Linear activity.",
+          success: true,
+          data: { awaitingUserInput: true }
+        };
+      }
+      if (decision.status === "cancelled") {
+        const cancelMessage = "Clear of Linear activity cancelled.";
+        await callback?.({ text: cancelMessage, source: message.content.source });
+        return {
+          text: cancelMessage,
+          success: true,
+          data: { cancelled: true }
+        };
+      }
+      await Promise.race([
+        linearService.clearActivityLog(accountId),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("Linear clear activity timeout")), CLEAR_ACTIVITY_TIMEOUT_MS))
+      ]);
       const successMessage = "✅ Linear activity log has been cleared.";
       await callback?.({
         text: successMessage,
@@ -100,7 +269,7 @@ import {
   ModelType
 } from "@elizaos/core";
 
-// src/generated/prompts/typescript/prompts.ts
+// src/prompts.ts
 var createCommentTemplate = `Extract comment details from the user's request to add a comment to a Linear issue.
 
 User request: "{{userMessage}}"
@@ -112,40 +281,41 @@ The user might express this in various ways:
 - "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:
+Respond with JSON only. Use this shape:
 {
-  "issueId": "Direct issue ID if explicitly mentioned (e.g., ENG-123)",
-  "issueDescription": "Description/keywords of the issue if no ID provided",
+  "issueId": "Direct issue ID if explicitly mentioned, for example ENG-123",
+  "issueDescription": "Description or keywords of the issue if no ID was provided",
   "commentBody": "The actual comment content to add",
-  "commentType": "note/reply/update/question/feedback (inferred from context)"
+  "commentType": "note|reply|update|question|feedback"
 }
 
-Extract the core message the user wants to convey as the comment body.`;
+Extract the core message the user wants to convey as the comment body.
+Omit unknown fields. Output only the JSON object, with no prose before or after it.`;
 var createIssueTemplate = `Given the user's request, extract the information needed to create a Linear issue.
 
 User request: "{{userMessage}}"
 
-Extract and return ONLY a JSON object (no markdown formatting, no code blocks) with the following structure:
+Respond with JSON only. Use this shape:
 {
   "title": "Brief, clear issue title",
-  "description": "Detailed description of the issue (optional, omit or use null if not provided)",
-  "teamKey": "Team key if mentioned (e.g., ENG, PROD) - omit or use null if not mentioned",
-  "priority": "Priority level if mentioned (1=urgent, 2=high, 3=normal, 4=low) - omit or use null if not mentioned",
-  "labels": ["label1", "label2"] (if any labels are mentioned, empty array if none),
-  "assignee": "Assignee username or email if mentioned - omit or use null if not mentioned"
+  "description": "Detailed description of the issue",
+  "teamKey": "Team key if mentioned, such as ENG or PROD",
+  "priority": 3,
+  "labels": ["label"],
+  "assignee": "Assignee username or email if mentioned"
 }
 
-Return only the JSON object, no other text.`;
+Omit optional fields when they are not provided. Output only the JSON object, with no prose before or after it.`;
 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:
+Respond with JSON only:
 {
-  "issueId": "The issue identifier (e.g., ENG-123, COM2-7)"
+  "issueId": "The issue identifier, such as ENG-123 or COM2-7"
 }
 
-Return only the JSON object, no other text.`;
+Output only the JSON object, with no prose before or after it.`;
 var getActivityTemplate = `Extract activity filter criteria from the user's request.
 
 User request: "{{userMessage}}"
@@ -158,22 +328,22 @@ The user might ask for activity in various ways:
 - "Recent comment activity" → action type + recency
 - "Failed operations this week" → success filter + time range
 
-Return ONLY a JSON object:
+Respond with JSON only. Use this shape:
 {
   "timeRange": {
-    "period": "today/yesterday/this-week/last-week/this-month",
-    "from": "ISO datetime if specific",
-    "to": "ISO datetime if specific"
+    "period": "today|yesterday|this-week|last-week|this-month",
+    "from": "ISO datetime if a specific start is mentioned",
+    "to": "ISO datetime if a specific end is mentioned"
   },
-  "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)
+  "actionTypes": ["create_issue"],
+  "resourceTypes": ["issue"],
+  "resourceId": "Specific resource ID if mentioned, such as ENG-123",
+  "user": "User name, or me for current user",
+  "successFilter": "success|failed|all",
+  "limit": 10
 }
 
-Only include fields that are clearly mentioned.`;
+Only include fields that are clearly mentioned. Output only the JSON object, with no prose before or after it.`;
 var getIssueTemplate = `Extract issue identification from the user's request.
 
 User request: "{{userMessage}}"
@@ -185,73 +355,25 @@ The user might reference an issue by:
 - Recency (e.g., "the latest bug", "most recent issue")
 - Team context (e.g., "newest issue in ELIZA team")
 
-Return ONLY a JSON object:
+Respond with JSON only. Use directId when an issue ID is explicitly mentioned:
+{
+  "directId": "Issue ID such as ENG-123"
+}
+
+When no issue ID is provided, use searchBy fields:
 {
-  "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)",
+    "assignee": "Name or email of assignee if mentioned",
+    "priority": "urgent|high|normal|low|1|2|3|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"
+    "state": "Issue state if mentioned, such as todo, in-progress, or done",
+    "recency": "latest|newest|recent|last",
+    "type": "bug|feature|task"
   }
 }
 
-Only include fields that are clearly mentioned or implied.`;
-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"
-  },
-  "leadFilter": "Project lead name if mentioned",
-  "showAll": true/false (true if user explicitly asks for "all")
-}
-
-Only include fields that are clearly mentioned.`;
-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" → 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.`;
+Only include fields that are clearly mentioned or implied. Output only the JSON object, with no prose before or after it.`;
 var searchIssuesTemplate = `Extract search criteria from the user's request for Linear issues.
 
 User request: "{{userMessage}}"
@@ -266,53 +388,199 @@ The user might express searches in various ways:
 - "Bugs that are almost done" → label + state filter
 - "Show me the oldest open issues" → state + sort order
 
-Extract and return ONLY a JSON object:
+Respond with JSON only. Use this shape:
 {
-  "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),
+  "query": "General search text for title or description",
+  "states": ["In Progress"],
+  "assignees": ["me"],
+  "priorities": ["high"],
+  "teams": ["ENG"],
+  "labels": ["bug"],
+  "hasAssignee": true,
   "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"
+    "field": "created|updated|completed",
+    "period": "today|yesterday|this-week|last-week|this-month|last-month",
+    "from": "ISO date if a specific start is mentioned",
+    "to": "ISO date if a specific end is mentioned"
   },
   "sort": {
-    "field": "created/updated/priority",
-    "order": "asc/desc"
+    "field": "created|updated|priority",
+    "order": "asc|desc"
   },
-  "limit": number (default 10)
+  "limit": 10
 }
 
-Only include fields that are clearly mentioned or implied. For "my" issues, set assignees to ["me"].`;
+Only include fields that are clearly mentioned or implied. For "my" issues, set assignees to ["me"]. Output only the JSON object, with no prose before or after it.`;
 var updateIssueTemplate = `Given the user's request to update a Linear issue, extract the information needed.
 
 User request: "{{userMessage}}"
 
-Extract and return ONLY a JSON object (no markdown formatting, no code blocks) with the following structure:
+Respond with JSON only. Use this shape:
 {
-  "issueId": "The issue identifier (e.g., ENG-123, COM2-7)",
+  "issueId": "Issue identifier such as ENG-123 or COM2-7",
   "updates": {
     "title": "New title if changing the title",
     "description": "New description if changing the description",
-    "priority": "Priority level if changing (1=urgent, 2=high, 3=normal, 4=low)",
-    "teamKey": "New team key if moving to another team (e.g., ENG, ELIZA, COM2)",
+    "priority": 3,
+    "teamKey": "New team key if moving to another team, such as ENG, ELIZA, or COM2",
     "assignee": "New assignee username or email if changing",
-    "status": "New status if changing (e.g., todo, in-progress, done, canceled)",
-    "labels": ["label1", "label2"] (if changing labels, empty array to clear)
+    "status": "todo|in-progress|done|canceled",
+    "labels": ["label"]
   }
 }
 
-Only include fields that are being updated. Return only the JSON object, no other text.`;
+Only include fields that are being updated. Use an empty labels array to clear all labels. Output only the JSON object, with no prose before or after it.`;
+
+// src/actions/parseLinearPrompt.ts
+var EMPTY_SCALAR_VALUES = new Set(["", "none", "null", "undefined", "n/a", "not provided"]);
+var EMPTY_LIST_VALUES = new Set([...EMPTY_SCALAR_VALUES, "clear", "clear all", "no labels"]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stripWrappingQuotes(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+}
+function normalizeListEntry(value) {
+  return stripWrappingQuotes(value.replace(/^\s*[-*]\s*/, "").trim());
+}
+function splitListString(value) {
+  let trimmed = value.trim();
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    trimmed = trimmed.slice(1, -1);
+  }
+  return trimmed.split(/[,\n]/).map(normalizeListEntry).filter(Boolean);
+}
+function parseLinearPromptResponse(response) {
+  try {
+    const trimmed = response.trim();
+    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+    const candidate = (fenced?.[1] ?? trimmed).trim();
+    const firstBrace = candidate.indexOf("{");
+    const lastBrace = candidate.lastIndexOf("}");
+    if (firstBrace < 0 || lastBrace <= firstBrace)
+      return {};
+    const parsed = JSON.parse(candidate.slice(firstBrace, lastBrace + 1));
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function getRecordValue(value) {
+  if (isRecord(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim().startsWith("{")) {
+    const parsed = parseLinearPromptResponse(value);
+    return Object.keys(parsed).length > 0 ? parsed : undefined;
+  }
+  return;
+}
+function getStringValue(value) {
+  if (typeof value === "string") {
+    const normalized = stripWrappingQuotes(value);
+    return EMPTY_SCALAR_VALUES.has(normalized.toLowerCase()) ? undefined : normalized;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return;
+}
+function getStringArrayValue(value) {
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => {
+      if (entry == null) {
+        return [];
+      }
+      if (typeof entry === "string") {
+        return splitListString(entry);
+      }
+      return [String(entry)];
+    }).filter(Boolean);
+  }
+  if (typeof value === "string") {
+    const normalized = stripWrappingQuotes(value);
+    if (EMPTY_LIST_VALUES.has(normalized.toLowerCase())) {
+      return [];
+    }
+    return splitListString(normalized);
+  }
+  return;
+}
+function getBooleanValue(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (["true", "yes", "y"].includes(normalized)) {
+      return true;
+    }
+    if (["false", "no", "n"].includes(normalized)) {
+      return false;
+    }
+  }
+  return;
+}
+function getNumberValue(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim();
+    if (!normalized) {
+      return;
+    }
+    const parsed = Number(normalized);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  }
+  return;
+}
+function getPriorityNumberValue(value) {
+  const numeric = getNumberValue(value);
+  if (numeric) {
+    return numeric;
+  }
+  const priority = getStringValue(value)?.toLowerCase();
+  if (!priority) {
+    return;
+  }
+  const priorityMap = {
+    urgent: 1,
+    high: 2,
+    normal: 3,
+    medium: 3,
+    low: 4
+  };
+  return priorityMap[priority];
+}
 
 // src/actions/createComment.ts
 var createCommentAction = {
   name: "CREATE_LINEAR_COMMENT",
+  contexts: ["tasks", "connectors", "automation"],
+  contextGate: { anyOf: ["tasks", "connectors", "automation"] },
+  roleGate: { minRole: "USER" },
   description: "Add a comment to a Linear issue",
+  descriptionCompressed: "add comment Linear issue",
+  parameters: [
+    {
+      name: "issueId",
+      description: "Linear issue id or identifier to comment on.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "body",
+      description: "Comment body to add to the issue.",
+      required: false,
+      schema: { type: "string" }
+    },
+    linearAccountIdParameter
+  ],
   similes: [
     "create-linear-comment",
     "add-linear-comment",
@@ -366,37 +634,17 @@ var createCommentAction = {
       }
     ]
   ],
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["create", "linear", "comment"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegex = /\b(?:create|linear|comment)\b/i;
-    const __avRegexOk = __avRegex.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const apiKey = runtime2.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
+  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
+    keywords: ["create", "linear", "comment"],
+    regexAlternation: "create|linear|comment"
+  }),
   async handler(runtime, message, _state, _options, callback) {
     try {
       const linearService = runtime.getService("linear");
       if (!linearService) {
         throw new Error("Linear service not available");
       }
+      const accountId = getLinearAccountId(runtime, _options);
       const content = message.content.text;
       if (!content) {
         const errorMessage = "Please provide a message with the issue and comment content.";
@@ -430,22 +678,28 @@ var createCommentAction = {
           }
         } 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 parsed = parseLinearPromptResponse(response);
+            if (Object.keys(parsed).length === 0) {
+              throw new Error("No fields found in model response");
+            }
+            const parsedIssueId = getStringValue(parsed.issueId);
+            const issueDescription = getStringValue(parsed.issueDescription);
+            const parsedCommentBody = getStringValue(parsed.commentBody) ?? "";
+            if (parsedIssueId) {
+              issueId = parsedIssueId;
+              commentBody = parsedCommentBody;
+            } else if (issueDescription) {
               const filters = {
-                query: parsed.issueDescription,
+                query: issueDescription,
                 limit: 5
               };
-              const defaultTeamKey = runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
+              const defaultTeamKey = linearService.getDefaultTeamKey(accountId) ?? runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
               if (defaultTeamKey) {
                 filters.team = defaultTeamKey;
               }
-              const issues = await linearService.searchIssues(filters);
+              const issues = await linearService.searchIssues(filters, accountId);
               if (issues.length === 0) {
-                const errorMessage = `No issues found matching "${parsed.issueDescription}". Please provide a specific issue ID.`;
+                const errorMessage = `No issues found matching "${issueDescription}". Please provide a specific issue ID.`;
                 await callback?.({
                   text: errorMessage,
                   source: message.content.source
@@ -457,13 +711,13 @@ var createCommentAction = {
               }
               if (issues.length === 1) {
                 issueId = issues[0].identifier;
-                commentBody = parsed.commentBody;
+                commentBody = parsedCommentBody;
               } 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}":
+                const clarifyMessage = `Found multiple issues matching "${issueDescription}":
 ${issueList.join(`
 `)}
 
@@ -482,15 +736,16 @@ Please specify which issue to comment on by its ID.`;
                       identifier: i.identifier,
                       title: i.title
                     })),
-                    pendingComment: parsed.commentBody
+                    pendingComment: parsedCommentBody
                   }
                 };
               }
             } else {
               throw new Error("No issue identifier or description found");
             }
-            if (parsed.commentType && parsed.commentType !== "note") {
-              commentBody = `[${parsed.commentType.toUpperCase()}] ${commentBody}`;
+            const commentType = getStringValue(parsed.commentType)?.toLowerCase();
+            if (commentType && commentType !== "note") {
+              commentBody = `[${commentType.toUpperCase()}] ${commentBody}`;
             }
           } catch (parseError) {
             logger2.warn("Failed to parse LLM response, falling back to regex:", parseError);
@@ -522,11 +777,11 @@ Please specify which issue to comment on by its ID.`;
           success: false
         };
       }
-      const issue = await linearService.getIssue(issueId);
+      const issue = await linearService.getIssue(issueId, accountId);
       const comment = await linearService.createComment({
         issueId: issue.id,
         body: commentBody
-      });
+      }, accountId);
       const successMessage = `✅ Comment added to issue ${issue.identifier}: "${commentBody}"`;
       await callback?.({
         text: successMessage,
@@ -540,7 +795,8 @@ Please specify which issue to comment on by its ID.`;
           issueId: issue.id,
           issueIdentifier: issue.identifier,
           commentBody,
-          createdAt: comment.createdAt instanceof Date ? comment.createdAt.toISOString() : comment.createdAt
+          createdAt: comment.createdAt instanceof Date ? comment.createdAt.toISOString() : comment.createdAt,
+          accountId
         }
       };
     } catch (error) {
@@ -565,7 +821,30 @@ import {
 } from "@elizaos/core";
 var createIssueAction = {
   name: "CREATE_LINEAR_ISSUE",
-  description: "Create a new issue in Linear",
+  contexts: ["tasks", "connectors", "automation"],
+  contextGate: { anyOf: ["tasks", "connectors", "automation"] },
+  roleGate: { minRole: "USER" },
+  description: "Create a new Linear issue with title, description, priority, team, assignee, and labels. Use when the user wants to file, log, or track a new ticket, bug, story, or task in Linear from chat.",
+  descriptionCompressed: "create new issue Linear",
+  parameters: [
+    {
+      name: "issueData",
+      description: "Structured Linear issue fields.",
+      required: false,
+      schema: {
+        type: "object",
+        properties: {
+          title: { type: "string" },
+          description: { type: "string" },
+          priority: { type: "number" },
+          teamId: { type: "string" },
+          assigneeId: { type: "string" },
+          labelIds: { type: "array", items: { type: "string" } }
+        }
+      }
+    },
+    linearAccountIdParameter
+  ],
   similes: ["create-linear-issue", "new-linear-issue", "add-linear-issue"],
   examples: [
     [
@@ -599,37 +878,17 @@ var createIssueAction = {
       }
     ]
   ],
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["create", "linear", "issue"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegex = /\b(?:create|linear|issue)\b/i;
-    const __avRegexOk = __avRegex.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const apiKey = runtime2.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
+  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
+    keywords: ["create", "linear", "issue"],
+    regexAlternation: "create|linear|issue"
+  }),
   async handler(runtime, message, _state, _options, callback) {
     try {
       const linearService = runtime.getService("linear");
       if (!linearService) {
         throw new Error("Linear service not available");
       }
+      const accountId = getLinearAccountId(runtime, _options);
       const content = message.content.text;
       if (!content) {
         const errorMessage = "Please provide a description for the issue.";
@@ -656,37 +915,40 @@ var createIssueAction = {
           throw new Error("Failed to extract issue information");
         }
         try {
-          const cleanedResponse = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
-          const parsed = JSON.parse(cleanedResponse);
+          const parsed = parseLinearPromptResponse(response);
+          if (Object.keys(parsed).length === 0) {
+            throw new Error("No fields found in model response");
+          }
           issueData = {
-            title: parsed.title || undefined,
-            description: parsed.description || undefined,
-            priority: parsed.priority ? Number(parsed.priority) : undefined
+            title: getStringValue(parsed.title),
+            description: getStringValue(parsed.description),
+            priority: getPriorityNumberValue(parsed.priority)
           };
-          if (parsed.teamKey) {
-            const teams = await linearService.getTeams();
-            const team = teams.find((t) => t.key.toLowerCase() === parsed.teamKey.toLowerCase());
+          const teamKey = getStringValue(parsed.teamKey);
+          if (teamKey) {
+            const teams = await linearService.getTeams(accountId);
+            const team = teams.find((t) => t.key.toLowerCase() === teamKey.toLowerCase());
             if (team) {
               issueData.teamId = team.id;
             }
           }
-          if (parsed.assignee && parsed.assignee !== "") {
-            const cleanAssignee = parsed.assignee.replace(/^@/, "");
-            const users = await linearService.getUsers();
+          const assignee = getStringValue(parsed.assignee);
+          if (assignee) {
+            const cleanAssignee = assignee.replace(/^@/, "");
+            const users = await linearService.getUsers(accountId);
             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 parsedLabels = getStringArrayValue(parsed.labels);
+          if (parsedLabels && parsedLabels.length > 0) {
+            const labels = await linearService.getLabels(issueData.teamId, accountId);
             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);
-                }
+            for (const labelName of parsedLabels) {
+              const label = labels.find((l) => l.name.toLowerCase() === labelName.toLowerCase());
+              if (label) {
+                labelIds.push(label.id);
               }
             }
             if (labelIds.length > 0) {
@@ -694,9 +956,9 @@ var createIssueAction = {
             }
           }
           if (!issueData.teamId) {
-            const defaultTeamKey = runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
+            const defaultTeamKey = linearService.getDefaultTeamKey(accountId) ?? runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
             if (defaultTeamKey) {
-              const teams = await linearService.getTeams();
+              const teams = await linearService.getTeams(accountId);
               const defaultTeam = teams.find((t) => t.key.toLowerCase() === defaultTeamKey.toLowerCase());
               if (defaultTeam) {
                 issueData.teamId = defaultTeam.id;
@@ -706,7 +968,7 @@ var createIssueAction = {
               }
             }
             if (!issueData.teamId) {
-              const teams = await linearService.getTeams();
+              const teams = await linearService.getTeams(accountId);
               if (teams.length > 0) {
                 issueData.teamId = teams[0].id;
                 logger3.warn(`No team specified, using first available team: ${teams[0].name}`);
@@ -719,8 +981,8 @@ var createIssueAction = {
             title: content.length > 100 ? `${content.substring(0, 100)}...` : content,
             description: content
           };
-          const defaultTeamKey = runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
-          const teams = await linearService.getTeams();
+          const defaultTeamKey = linearService.getDefaultTeamKey(accountId) ?? runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
+          const teams = await linearService.getTeams(accountId);
           if (defaultTeamKey) {
             const defaultTeam = teams.find((t) => t.key.toLowerCase() === defaultTeamKey.toLowerCase());
             if (defaultTeam) {
@@ -756,7 +1018,7 @@ var createIssueAction = {
           success: false
         };
       }
-      const issue = await linearService.createIssue(issueData);
+      const issue = await linearService.createIssue(issueData, accountId);
       const successMessage = `✅ Created Linear issue: ${issue.title} (${issue.identifier})
 
 View it at: ${issue.url}`;
@@ -770,7 +1032,8 @@ View it at: ${issue.url}`;
         data: {
           issueId: issue.id,
           identifier: issue.identifier,
-          url: issue.url
+          url: issue.url,
+          accountId
         }
       };
     } catch (error) {
@@ -788,14 +1051,101 @@ View it at: ${issue.url}`;
   }
 };
 
+// src/actions/deleteComment.ts
+import {
+  logger as logger4
+} from "@elizaos/core";
+var deleteCommentAction = {
+  name: "DELETE_LINEAR_COMMENT",
+  contexts: ["tasks", "connectors", "automation"],
+  contextGate: { anyOf: ["tasks", "connectors", "automation"] },
+  roleGate: { minRole: "USER" },
+  description: "Delete a specific Linear comment by its comment id. Use when the user asks to remove, retract, or erase a comment they previously left on a Linear issue.",
+  descriptionCompressed: "delete Linear comment id",
+  parameters: [
+    {
+      name: "commentId",
+      description: "Linear comment id to delete.",
+      required: false,
+      schema: { type: "string" }
+    },
+    linearAccountIdParameter
+  ],
+  similes: ["remove-linear-comment", "erase-linear-comment"],
+  examples: [
+    [
+      {
+        name: "User",
+        content: { text: "Delete comment abc-123 from ENG-456." }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll delete that comment.",
+          actions: ["DELETE_LINEAR_COMMENT"]
+        }
+      }
+    ]
+  ],
+  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
+    keywords: ["delete", "remove", "linear", "comment"],
+    regexAlternation: "delete|remove|linear|comment"
+  }),
+  async handler(runtime, message, _state, _options, callback) {
+    try {
+      const linearService = runtime.getService("linear");
+      if (!linearService) {
+        throw new Error("Linear service not available");
+      }
+      const accountId = getLinearAccountId(runtime, _options);
+      const params = _options?.parameters;
+      const commentId = params?.commentId?.trim() ?? "";
+      if (!commentId) {
+        const errorMessage = "Please provide a commentId to delete.";
+        await callback?.({ text: errorMessage, source: message.content.source });
+        return { text: errorMessage, success: false };
+      }
+      await linearService.deleteComment(commentId, accountId);
+      const successMessage = `Deleted comment ${commentId}.`;
+      await callback?.({ text: successMessage, source: message.content.source });
+      return {
+        text: successMessage,
+        success: true,
+        data: { commentId, accountId }
+      };
+    } catch (error) {
+      logger4.error("Failed to delete comment:", error);
+      const errorMessage = `Failed to delete comment: ${error instanceof Error ? error.message : "Unknown error"}`;
+      await callback?.({ text: errorMessage, source: message.content.source });
+      return { text: errorMessage, success: false };
+    }
+  }
+};
+
 // src/actions/deleteIssue.ts
 import {
-  logger as logger4,
-  ModelType as ModelType3
+  logger as logger5,
+  ModelType as ModelType3,
+  requireConfirmation as requireConfirmation2
 } from "@elizaos/core";
+var LINEAR_MODEL_TIMEOUT_MS = 15000;
+var LINEAR_ISSUE_TITLE_MAX_CHARS = 300;
 var deleteIssueAction = {
   name: "DELETE_LINEAR_ISSUE",
+  contexts: ["tasks", "connectors", "automation"],
+  contextGate: { anyOf: ["tasks", "connectors", "automation"] },
+  roleGate: { minRole: "USER" },
   description: "Delete (archive) an issue in Linear",
+  descriptionCompressed: "delete (archive) issue Linear",
+  parameters: [
+    {
+      name: "issueId",
+      description: "Linear issue id or identifier to archive.",
+      required: false,
+      schema: { type: "string" }
+    },
+    linearAccountIdParameter
+  ],
   similes: [
     "delete-linear-issue",
     "archive-linear-issue",
@@ -849,37 +1199,17 @@ var deleteIssueAction = {
       }
     ]
   ],
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["delete", "linear", "issue"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegex = /\b(?:delete|linear|issue)\b/i;
-    const __avRegexOk = __avRegex.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const apiKey = runtime2.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
+  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
+    keywords: ["delete", "linear", "issue"],
+    regexAlternation: "delete|linear|issue"
+  }),
   async handler(runtime, message, _state, _options, callback) {
     try {
       const linearService = runtime.getService("linear");
       if (!linearService) {
         throw new Error("Linear service not available");
       }
+      const accountId = getLinearAccountId(runtime, _options);
       const content = message.content.text;
       if (!content) {
         const errorMessage = "Please specify which issue to delete.";
@@ -898,21 +1228,26 @@ var deleteIssueAction = {
         issueId = params.issueId;
       } else {
         const prompt = deleteIssueTemplate.replace("{{userMessage}}", content);
-        const response = await runtime.useModel(ModelType3.TEXT_LARGE, {
-          prompt
-        });
+        const response = await Promise.race([
+          runtime.useModel(ModelType3.TEXT_LARGE, {
+            prompt
+          }),
+          new Promise((_, reject) => setTimeout(() => reject(new Error("Linear issue extraction timeout")), LINEAR_MODEL_TIMEOUT_MS))
+        ]);
         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;
+          const parsed = parseLinearPromptResponse(response);
+          if (Object.keys(parsed).length === 0) {
+            throw new Error("No fields found in model response");
+          }
+          issueId = getStringValue(parsed.issueId) ?? "";
           if (!issueId) {
             throw new Error("Issue ID not found in parsed response");
           }
         } catch (parseError) {
-          logger4.warn("Failed to parse LLM response, falling back to regex parsing:", 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.";
@@ -928,11 +1263,35 @@ var deleteIssueAction = {
           issueId = issueMatch[1];
         }
       }
-      const issue = await linearService.getIssue(issueId);
-      const issueTitle = issue.title;
+      const issue = await linearService.getIssue(issueId, accountId);
+      const issueTitle = issue.title.slice(0, LINEAR_ISSUE_TITLE_MAX_CHARS);
       const issueIdentifier = issue.identifier;
-      logger4.info(`Archiving issue ${issueIdentifier}: ${issueTitle}`);
-      await linearService.deleteIssue(issueId);
+      const decision = await requireConfirmation2({
+        runtime,
+        message,
+        actionName: "DELETE_LINEAR_ISSUE",
+        pendingKey: `archive:${issue.id}`,
+        prompt: `Archive issue ${issueIdentifier}: "${issueTitle}"? This moves it out of active views. Reply "yes" to confirm.`,
+        callback
+      });
+      if (decision.status === "pending") {
+        return {
+          text: `Awaiting confirmation to archive ${issueIdentifier}.`,
+          success: true,
+          data: { awaitingUserInput: true, issueId: issue.id, identifier: issueIdentifier }
+        };
+      }
+      if (decision.status === "cancelled") {
+        const cancelMessage = `Archive of ${issueIdentifier} cancelled.`;
+        await callback?.({ text: cancelMessage, source: message.content.source });
+        return {
+          text: cancelMessage,
+          success: true,
+          data: { cancelled: true, issueId: issue.id, identifier: issueIdentifier }
+        };
+      }
+      logger5.info(`Archiving issue ${issueIdentifier}: ${issueTitle}`);
+      await linearService.deleteIssue(issueId, accountId);
       const successMessage = `✅ Successfully archived issue ${issueIdentifier}: "${issueTitle}"
 
 The issue has been moved to the archived state and will no longer appear in active views.`;
@@ -947,11 +1306,12 @@ The issue has been moved to the archived state and will no longer appear in acti
           issueId: issue.id,
           identifier: issueIdentifier,
           title: issueTitle,
-          archived: true
+          archived: true,
+          accountId
         }
       };
     } catch (error) {
-      logger4.error("Failed to delete issue:", error);
+      logger5.error("Failed to delete issue:", error);
       const errorMessage = `❌ Failed to delete issue: ${error instanceof Error ? error.message : "Unknown error"}`;
       await callback?.({
         text: errorMessage,
@@ -967,18 +1327,49 @@ The issue has been moved to the archived state and will no longer appear in acti
 
 // src/actions/getActivity.ts
 import {
-  logger as logger5,
+  logger as logger6,
   ModelType as ModelType4
 } from "@elizaos/core";
+function formatActivityDetail(value) {
+  if (value === null || value === undefined) {
+    return "none";
+  }
+  if (Array.isArray(value)) {
+    return value.map(formatActivityDetail).join(", ");
+  }
+  if (typeof value === "object") {
+    return Object.entries(value).map(([key, nestedValue]) => `${key}=${formatActivityDetail(nestedValue)}`).join("; ");
+  }
+  return String(value);
+}
 var getActivityAction = {
   name: "GET_LINEAR_ACTIVITY",
+  contexts: ["tasks", "connectors", "automation"],
+  contextGate: { anyOf: ["tasks", "connectors", "automation"] },
+  roleGate: { minRole: "USER" },
   description: "Get recent Linear activity log with optional filters",
+  descriptionCompressed: "get recent Linear activity log w/ optional filter",
   similes: [
     "get-linear-activity",
     "show-linear-activity",
     "view-linear-activity",
     "check-linear-activity"
   ],
+  parameters: [
+    {
+      name: "filters",
+      description: "Optional activity filters, e.g. fromDate ISO timestamp, action, resource_type, resource_id, or success.",
+      required: false,
+      schema: { type: "object" }
+    },
+    {
+      name: "limit",
+      description: "Maximum number of activity log entries to return.",
+      required: false,
+      schema: { type: "number" }
+    },
+    linearAccountIdParameter
+  ],
   examples: [
     [
       {
@@ -1026,40 +1417,21 @@ var getActivityAction = {
       }
     ]
   ],
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["get", "linear", "activity"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegex = /\b(?:get|linear|activity)\b/i;
-    const __avRegexOk = __avRegex.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const apiKey = runtime2.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
+  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
+    keywords: ["get", "linear", "activity"],
+    regexAlternation: "get|linear|activity"
+  }),
   async handler(runtime, message, _state, _options, callback) {
     try {
       const linearService = runtime.getService("linear");
       if (!linearService) {
         throw new Error("Linear service not available");
       }
+      const accountId = getLinearAccountId(runtime, _options);
       const content = message.content.text || "";
-      const filters = {};
-      let limit = 10;
+      const params = _options?.parameters ?? {};
+      const filters = { ...params.filters ?? {} };
+      let limit = typeof params.limit === "number" && Number.isFinite(params.limit) ? Math.max(1, Math.floor(params.limit)) : 10;
       if (content) {
         const prompt = getActivityTemplate.replace("{{userMessage}}", content);
         const response = await runtime.useModel(ModelType4.TEXT_LARGE, {
@@ -1067,14 +1439,20 @@ var getActivityAction = {
         });
         if (response) {
           try {
-            const parsed = JSON.parse(response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim());
-            if (parsed.timeRange) {
+            const parsed = parseLinearPromptResponse(response);
+            if (Object.keys(parsed).length === 0) {
+              throw new Error("No fields found in model response");
+            }
+            const timeRange = getRecordValue(parsed.timeRange);
+            if (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) {
+              const from = getStringValue(timeRange.from);
+              const period = getStringValue(timeRange.period);
+              if (from) {
+                fromDate = new Date(from);
+              } else if (period) {
+                switch (period) {
                   case "today":
                     fromDate = new Date(now.setHours(0, 0, 0, 0));
                     break;
@@ -1099,25 +1477,29 @@ var getActivityAction = {
                 filters.fromDate = fromDate.toISOString();
               }
             }
-            if (parsed.actionTypes && parsed.actionTypes.length > 0) {
-              filters.action = parsed.actionTypes[0];
+            const actionTypes = getStringArrayValue(parsed.actionTypes);
+            if (actionTypes && actionTypes.length > 0) {
+              filters.action = actionTypes[0];
             }
-            if (parsed.resourceTypes && parsed.resourceTypes.length > 0) {
-              filters.resource_type = parsed.resourceTypes[0];
+            const resourceTypes = getStringArrayValue(parsed.resourceTypes);
+            if (resourceTypes && resourceTypes.length > 0) {
+              filters.resource_type = resourceTypes[0];
             }
-            if (parsed.resourceId) {
-              filters.resource_id = parsed.resourceId;
+            const resourceId = getStringValue(parsed.resourceId);
+            if (resourceId) {
+              filters.resource_id = resourceId;
             }
-            if (parsed.successFilter && parsed.successFilter !== "all") {
-              filters.success = parsed.successFilter === "success";
+            const successFilter = getStringValue(parsed.successFilter);
+            if (successFilter && successFilter !== "all") {
+              filters.success = successFilter === "success";
             }
-            limit = parsed.limit || 10;
+            limit = getNumberValue(parsed.limit) || 10;
           } catch (parseError) {
-            logger5.warn("Failed to parse activity filters:", parseError);
+            logger6.warn("Failed to parse activity filters:", parseError);
           }
         }
       }
-      let activity = linearService.getActivityLog(limit * 2, filters);
+      let activity = linearService.getActivityLog(limit * 2, filters, accountId);
       if (filters.fromDate) {
         const fromDateValue = filters.fromDate;
         const fromDate = typeof fromDateValue === "string" ? fromDateValue : fromDateValue instanceof Date ? fromDateValue.toISOString() : String(fromDateValue);
@@ -1137,14 +1519,15 @@ var getActivityAction = {
           text: noActivityMessage,
           success: true,
           data: {
-            activity: []
+            activity: [],
+            accountId
           }
         };
       }
       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(", ");
+        const details = Object.entries(item.details).filter(([key]) => key !== "filters").map(([key, value]) => `${key}: ${formatActivityDetail(value)}`).join(", ");
         return `${index + 1}. ${status} ${item.action} on ${item.resource_type} ${item.resource_id}
    Time: ${time}
    ${details ? `Details: ${details}` : ""}${item.error ? `
@@ -1171,18 +1554,19 @@ ${activityText}`;
             resource_id: item.resource_id,
             success: item.success,
             error: item.error,
-            details: JSON.stringify(item.details),
+            details: formatActivityDetail(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
+          count: activity.length,
+          accountId
         }
       };
     } catch (error) {
-      logger5.error("Failed to get activity:", error);
+      logger6.error("Failed to get activity:", error);
       const errorMessage = `❌ Failed to get activity: ${error instanceof Error ? error.message : "Unknown error"}`;
       await callback?.({
         text: errorMessage,
@@ -1198,12 +1582,16 @@ ${activityText}`;
 
 // src/actions/getIssue.ts
 import {
-  logger as logger6,
+  logger as logger7,
   ModelType as ModelType5
 } from "@elizaos/core";
 var getIssueAction = {
   name: "GET_LINEAR_ISSUE",
+  contexts: ["tasks", "connectors", "knowledge"],
+  contextGate: { anyOf: ["tasks", "connectors", "knowledge"] },
+  roleGate: { minRole: "USER" },
   description: "Get details of a specific Linear issue",
+  descriptionCompressed: "get detail specific Linear issue",
   similes: [
     "get-linear-issue",
     "show-linear-issue",
@@ -1211,6 +1599,21 @@ var getIssueAction = {
     "check-linear-issue",
     "find-linear-issue"
   ],
+  parameters: [
+    {
+      name: "issueId",
+      description: "Linear issue identifier or id, e.g. ENG-123.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "query",
+      description: "Search text when the exact Linear issue identifier is unknown.",
+      required: false,
+      schema: { type: "string" }
+    },
+    linearAccountIdParameter
+  ],
   examples: [
     [
       {
@@ -1258,38 +1661,19 @@ var getIssueAction = {
       }
     ]
   ],
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["get", "linear", "issue"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegex = /\b(?:get|linear|issue)\b/i;
-    const __avRegexOk = __avRegex.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const apiKey = runtime2.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
+  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
+    keywords: ["get", "linear", "issue"],
+    regexAlternation: "get|linear|issue"
+  }),
   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;
+      const accountId = getLinearAccountId(runtime, _options);
+      const params = _options?.parameters ?? {};
+      const content = params.query ?? params.issueId ?? message.content.text;
       if (!content) {
         const errorMessage2 = "Please specify which issue you want to see.";
         await callback?.({
@@ -1301,6 +1685,10 @@ var getIssueAction = {
           success: false
         };
       }
+      if (params.issueId) {
+        const issue = await linearService.getIssue(params.issueId, accountId);
+        return await formatIssueResponse(issue, callback, message);
+      }
       const prompt = getIssueTemplate.replace("{{userMessage}}", content);
       const response = await runtime.useModel(ModelType5.TEXT_LARGE, {
         prompt
@@ -1308,26 +1696,34 @@ var getIssueAction = {
       if (!response) {
         const issueMatch = content.match(/(\w+-\d+)/);
         if (issueMatch) {
-          const issue = await linearService.getIssue(issueMatch[1]);
+          const issue = await linearService.getIssue(issueMatch[1], accountId);
           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);
+        const parsed = parseLinearPromptResponse(response);
+        if (Object.keys(parsed).length === 0) {
+          throw new Error("No fields found in model response");
+        }
+        const directId = getStringValue(parsed.directId);
+        if (directId) {
+          const issue = await linearService.getIssue(directId, accountId);
           return await formatIssueResponse(issue, callback, message);
         }
-        if (parsed.searchBy && Object.keys(parsed.searchBy).length > 0) {
+        const searchBy = getRecordValue(parsed.searchBy);
+        if (searchBy && Object.keys(searchBy).length > 0) {
           const filters = {};
-          if (parsed.searchBy.title) {
-            filters.query = parsed.searchBy.title;
+          const title = getStringValue(searchBy.title);
+          if (title) {
+            filters.query = title;
           }
-          if (parsed.searchBy.assignee) {
-            filters.assignee = [parsed.searchBy.assignee];
+          const assignee = getStringValue(searchBy.assignee);
+          if (assignee) {
+            filters.assignee = [assignee];
           }
-          if (parsed.searchBy.priority) {
+          const priorityValue = getStringValue(searchBy.priority);
+          if (priorityValue) {
             const priorityMap = {
               urgent: 1,
               high: 2,
@@ -1338,25 +1734,27 @@ var getIssueAction = {
               "3": 3,
               "4": 4
             };
-            const priority = priorityMap[parsed.searchBy.priority.toLowerCase()];
+            const priority = priorityMap[priorityValue.toLowerCase()];
             if (priority) {
               filters.priority = [priority];
             }
           }
-          if (parsed.searchBy.team) {
-            filters.team = parsed.searchBy.team;
+          const team = getStringValue(searchBy.team);
+          if (team) {
+            filters.team = team;
           }
-          if (parsed.searchBy.state) {
-            filters.state = [parsed.searchBy.state];
+          const state = getStringValue(searchBy.state);
+          if (state) {
+            filters.state = [state];
           }
-          const defaultTeamKey = runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
+          const defaultTeamKey = linearService.getDefaultTeamKey(accountId) ?? 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
-          });
+            limit: getStringValue(searchBy.recency) ? 10 : 5
+          }, accountId);
           if (issues.length === 0) {
             const noResultsMessage = "No issues found matching your criteria.";
             await callback?.({
@@ -1368,18 +1766,18 @@ var getIssueAction = {
               success: false
             };
           }
-          if (parsed.searchBy.recency) {
+          if (getStringValue(searchBy.recency)) {
             issues.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
           }
-          if (parsed.searchBy.recency && issues.length > 0) {
+          if (getStringValue(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 state2 = await issue.state;
+            return `${index + 1}. ${issue.identifier}: ${issue.title} (${state2?.name || "No state"})`;
           }));
           const clarifyMessage = `Found ${issues.length} issues matching your criteria:
 ${issueList.join(`
@@ -1404,10 +1802,10 @@ Please specify which one you want to see by its ID.`;
           };
         }
       } catch (parseError) {
-        logger6.warn("Failed to parse LLM response, falling back to regex:", parseError);
+        logger7.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]);
+          const issue = await linearService.getIssue(issueMatch[1], accountId);
           return await formatIssueResponse(issue, callback, message);
         }
       }
@@ -1421,7 +1819,7 @@ Please specify which one you want to see by its ID.`;
         success: false
       };
     } catch (error) {
-      logger6.error("Failed to get issue:", error);
+      logger7.error("Failed to get issue:", error);
       const errorMessage = `❌ Failed to get issue: ${error instanceof Error ? error.message : "Unknown error"}`;
       await callback?.({
         text: errorMessage,
@@ -1512,489 +1910,148 @@ View in Linear: ${issue.url}`;
   };
 }
 
-// src/actions/listProjects.ts
+// src/actions/listComments.ts
 import {
-  logger as logger7,
-  ModelType as ModelType6
+  logger as logger8
 } 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"
+var listCommentsAction = {
+  name: "LIST_LINEAR_COMMENTS",
+  contexts: ["tasks", "connectors", "automation"],
+  contextGate: { anyOf: ["tasks", "connectors", "automation"] },
+  roleGate: { minRole: "USER" },
+  description: "List comments on a Linear issue",
+  descriptionCompressed: "list comment Linear issue",
+  parameters: [
+    {
+      name: "issueId",
+      description: "Linear issue id or identifier to list comments for.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "limit",
+      description: "Maximum number of comments to return (default 25, max 100).",
+      required: false,
+      schema: { type: "number" }
+    },
+    linearAccountIdParameter
   ],
+  similes: ["get-linear-comments", "show-linear-comments", "fetch-linear-comments"],
   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: "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: "Show me projects for the engineering team"
-        }
+        content: { text: "Show the comments on ENG-123." }
       },
       {
         name: "Assistant",
         content: {
-          text: "I'll find the projects for the engineering team.",
-          actions: ["LIST_LINEAR_PROJECTS"]
+          text: "Here are the comments on ENG-123.",
+          actions: ["LIST_LINEAR_COMMENTS"]
         }
       }
     ]
   ],
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["list", "linear", "projects"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegex = /\b(?:list|linear|projects)\b/i;
-    const __avRegexOk = __avRegex.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const apiKey = runtime2.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
+  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
+    keywords: ["list", "comments", "linear", "issue"],
+    regexAlternation: "list|comments|linear|issue"
+  }),
   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 || "";
-      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) {
-          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;
-                logger7.info(`Filtering projects by team: ${team.name} (${team.key})`);
-              }
-            }
-            showAll = parsed.showAll === true;
-            stateFilter = parsed.stateFilter;
-          } catch (parseError) {
-            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})`);
-              }
-            }
-            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;
-            logger7.info(`Applying default team filter for projects: ${defaultTeam.name} (${defaultTeam.key})`);
-          }
+      const accountId = getLinearAccountId(runtime, _options);
+      const params = _options?.parameters;
+      const issueId = params?.issueId?.trim() ?? "";
+      const limit = typeof params?.limit === "number" ? Math.min(Math.max(1, params.limit), 100) : 25;
+      if (!issueId) {
+        const match = message.content.text?.match(/([A-Z]+-\d+)/);
+        if (!match) {
+          const errorMessage = "Please provide an issueId to list comments for.";
+          await callback?.({
+            text: errorMessage,
+            source: message.content.source
+          });
+          return { text: errorMessage, success: false };
         }
+        const extractedId = match[1];
+        const comments2 = await linearService.listComments(extractedId, limit, accountId);
+        return formatCommentResult(extractedId, comments2, message, callback);
       }
-      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: noProjectsMessage,
-          source: message.content.source
-        });
-        return {
-          text: noProjectsMessage,
-          success: true,
-          data: {
-            projects: []
-          }
-        };
-      }
-      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: resultMessage,
-        source: message.content.source
-      });
-      return {
-        text: `Found ${projects.length} project${projects.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
-          })),
-          count: projects.length,
-          filters: {
-            team: teamId,
-            state: stateFilter
-          }
-        }
-      };
+      const comments = await linearService.listComments(issueId, limit, accountId);
+      return formatCommentResult(issueId, comments, message, callback);
     } catch (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
-      });
-      return {
-        text: errorMessage,
-        success: false
-      };
+      logger8.error("Failed to list comments:", error);
+      const errorMessage = `Failed to list comments: ${error instanceof Error ? error.message : "Unknown error"}`;
+      await callback?.({ text: errorMessage, source: message.content.source });
+      return { text: errorMessage, success: false };
     }
   }
 };
-
-// src/actions/listTeams.ts
-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"]
-        }
-      }
-    ],
-    [
-      {
-        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"]
-        }
-      }
-    ]
-  ],
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["list", "linear", "teams"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegex = /\b(?:list|linear|teams)\b/i;
-    const __avRegexOk = __avRegex.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const apiKey = runtime2.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } 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 || "";
-      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 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) {
-        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
-        });
-        return {
-          text: noTeamsMessage,
-          success: true,
-          data: {
-            teams: []
-          }
-        };
-      }
-      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 Object.assign(team, {
-            memberCount: members.length,
-            projectCount: projects.length,
-            membersList: specificTeam ? members.slice(0, 5) : []
-          });
-        }));
-      }
-      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 ?? 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 ?? 0) > 5 ? " ..." : ""}`;
-          }
-        }
-        return info;
-      }).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}`;
-      await callback?.({
-        text: resultMessage,
-        source: message.content.source
-      });
-      return {
-        text: `Found ${teams.length} team${teams.length === 1 ? "" : "s"}`,
-        success: true,
-        data: {
-          teams: teamsWithDetails.map((t) => ({
-            id: t.id,
-            name: t.name,
-            key: t.key,
-            description: t.description,
-            memberCount: t.memberCount,
-            projectCount: t.projectCount
-          })),
-          count: teams.length,
-          filters: {
-            name: nameFilter,
-            specific: specificTeam
-          }
-        }
-      };
-    } catch (error) {
-      logger8.error("Failed to list teams:", error);
-      const errorMessage = `❌ Failed to list teams: ${error instanceof Error ? error.message : "Unknown error"}`;
-      await callback?.({
-        text: errorMessage,
-        source: message.content.source
-      });
-      return {
-        text: errorMessage,
-        success: false
-      };
-    }
+async function formatCommentResult(issueId, comments, message, callback) {
+  if (comments.length === 0) {
+    const text2 = `No comments on issue ${issueId}.`;
+    await callback?.({ text: text2, source: message.content.source });
+    return { text: text2, success: true, data: { issueId, comments: [] } };
   }
-};
+  const lines = await Promise.all(comments.map(async (c) => {
+    const user = await c.user;
+    const name = user?.name ?? "unknown";
+    const created = c.createdAt ? new Date(c.createdAt).toISOString().slice(0, 10) : "?";
+    const body = (c.body ?? "").slice(0, 200);
+    return `- [${c.id}] ${name} (${created}): ${body}`;
+  }));
+  const text = `${comments.length} comment(s) on ${issueId}:
+${lines.join(`
+`)}`;
+  await callback?.({ text, source: message.content.source });
+  return {
+    text,
+    success: true,
+    data: {
+      issueId,
+      count: comments.length,
+      comments: comments.map((c) => ({ id: c.id }))
+    }
+  };
+}
 
 // src/actions/searchIssues.ts
 import {
   logger as logger9,
-  ModelType as ModelType8
+  ModelType as ModelType6
 } from "@elizaos/core";
 var searchTemplate = searchIssuesTemplate;
 var searchIssuesAction = {
   name: "SEARCH_LINEAR_ISSUES",
+  contexts: ["tasks", "connectors", "knowledge"],
+  contextGate: { anyOf: ["tasks", "connectors", "knowledge"] },
+  roleGate: { minRole: "USER" },
   description: "Search for issues in Linear with various filters",
+  descriptionCompressed: "search issue Linear w/ various filter",
   similes: [
     "search-linear-issues",
     "find-linear-issues",
     "query-linear-issues",
     "list-linear-issues"
   ],
+  parameters: [
+    {
+      name: "filters",
+      description: "Structured Linear issue filters: query, state, assignee, priority, team, label, and limit.",
+      required: false,
+      schema: { type: "object" }
+    },
+    {
+      name: "limit",
+      description: "Maximum number of issues to return.",
+      required: false,
+      schema: { type: "number" }
+    },
+    linearAccountIdParameter
+  ],
   examples: [
     [
       {
@@ -2042,37 +2099,17 @@ var searchIssuesAction = {
       }
     ]
   ],
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["search", "linear", "issues"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegex = /\b(?:search|linear|issues)\b/i;
-    const __avRegexOk = __avRegex.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const apiKey = runtime2.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
+  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
+    keywords: ["search", "linear", "issues"],
+    regexAlternation: "search|linear|issues"
+  }),
   async handler(runtime, message, _state, _options, callback) {
     try {
       const linearService = runtime.getService("linear");
       if (!linearService) {
         throw new Error("Linear service not available");
       }
+      const accountId = getLinearAccountId(runtime, _options);
       const content = message.content.text;
       if (!content) {
         const errorMessage = "Please provide search criteria for issues.";
@@ -2091,28 +2128,32 @@ var searchIssuesAction = {
         filters = params.filters;
       } else {
         const prompt = searchTemplate.replace("{{userMessage}}", content);
-        const response = await runtime.useModel(ModelType8.TEXT_LARGE, {
+        const response = await runtime.useModel(ModelType6.TEXT_LARGE, {
           prompt
         });
         if (!response) {
           filters = { query: content };
         } else {
           try {
-            const cleanedResponse = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
-            const parsed = JSON.parse(cleanedResponse);
+            const parsed = parseLinearPromptResponse(response);
+            if (Object.keys(parsed).length === 0) {
+              throw new Error("No fields found in model response");
+            }
             filters = {
-              query: parsed.query,
-              limit: parsed.limit || 10
+              query: getStringValue(parsed.query),
+              limit: getNumberValue(parsed.limit) || 10
             };
-            if (parsed.states && parsed.states.length > 0) {
-              filters.state = parsed.states;
+            const states = getStringArrayValue(parsed.states);
+            if (states && states.length > 0) {
+              filters.state = states;
             }
-            if (parsed.assignees && parsed.assignees.length > 0) {
+            const assignees = getStringArrayValue(parsed.assignees);
+            if (assignees && assignees.length > 0) {
               const processedAssignees = [];
-              for (const assignee of parsed.assignees) {
+              for (const assignee of assignees) {
                 if (assignee.toLowerCase() === "me") {
                   try {
-                    const currentUser = await linearService.getCurrentUser();
+                    const currentUser = await linearService.getCurrentUser(accountId);
                     processedAssignees.push(currentUser.email);
                   } catch {
                     logger9.warn('Could not resolve "me" to current user');
@@ -2125,10 +2166,11 @@ var searchIssuesAction = {
                 filters.assignee = processedAssignees;
               }
             }
-            if (parsed.hasAssignee === false) {
+            if (getBooleanValue(parsed.hasAssignee) === false) {
               filters.query = filters.query ? `${filters.query} unassigned` : "unassigned";
             }
-            if (parsed.priorities && parsed.priorities.length > 0) {
+            const parsedPriorities = getStringArrayValue(parsed.priorities);
+            if (parsedPriorities && parsedPriorities.length > 0) {
               const priorityMap = {
                 urgent: 1,
                 high: 2,
@@ -2139,16 +2181,18 @@ var searchIssuesAction = {
                 "3": 3,
                 "4": 4
               };
-              const priorities = parsed.priorities.map((p) => priorityMap[p.toLowerCase()]).filter(Boolean);
+              const priorities = parsedPriorities.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];
+            const teams = getStringArrayValue(parsed.teams);
+            if (teams && teams.length > 0) {
+              filters.team = teams[0];
             }
-            if (parsed.labels && parsed.labels.length > 0) {
-              filters.label = parsed.labels;
+            const labels = getStringArrayValue(parsed.labels);
+            if (labels && labels.length > 0) {
+              filters.label = labels;
             }
             Object.keys(filters).forEach((key) => {
               if (filters[key] === undefined) {
@@ -2162,7 +2206,7 @@ var searchIssuesAction = {
         }
       }
       if (!filters.team) {
-        const defaultTeamKey = runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
+        const defaultTeamKey = linearService.getDefaultTeamKey(accountId) ?? 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) {
@@ -2172,7 +2216,7 @@ var searchIssuesAction = {
         }
       }
       filters.limit = params?.limit ?? filters.limit ?? 10;
-      const issues = await linearService.searchIssues(filters);
+      const issues = await linearService.searchIssues(filters, accountId);
       if (issues.length === 0) {
         const noResultsMessage = "No issues found matching your search criteria.";
         await callback?.({
@@ -2185,7 +2229,8 @@ var searchIssuesAction = {
           data: {
             issues: [],
             filters: filters ? { ...filters } : undefined,
-            count: 0
+            count: 0,
+            accountId
           }
         };
       }
@@ -2229,7 +2274,8 @@ ${issueText}`;
             };
           })),
           filters: filters ? { ...filters } : undefined,
-          count: issues.length
+          count: issues.length,
+          accountId
         }
       };
     } catch (error) {
@@ -2247,223 +2293,159 @@ ${issueText}`;
   }
 };
 
-// src/actions/updateIssue.ts
+// src/actions/updateComment.ts
 import {
-  logger as logger10,
-  ModelType as ModelType9
+  logger as logger10
 } 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: "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: "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"]
-        }
-      }
-    ]
-  ],
-  validate: async (runtime, message, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["update", "linear", "issue"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegex = /\b(?:update|linear|issue)\b/i;
-    const __avRegexOk = __avRegex.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
+async function handleUpdateComment(runtime, message, _state, _options, callback) {
+  try {
+    const linearService = runtime.getService("linear");
+    if (!linearService) {
+      throw new Error("Linear service not available");
+    }
+    const accountId = getLinearAccountId(runtime, _options);
+    const params = _options?.parameters;
+    const commentId = params?.commentId?.trim() ?? "";
+    const body = params?.body?.trim() ?? "";
+    if (!commentId || !body) {
+      const errorMessage = "Please provide both commentId and body to update a comment.";
+      await callback?.({ text: errorMessage, source: message.content.source });
+      return { text: errorMessage, success: false };
     }
-    const __avLegacyValidate = async (runtime2, _message, _state) => {
-      const apiKey = runtime2.getSetting("LINEAR_API_KEY");
-      return !!apiKey;
+    const comment = await linearService.updateComment(commentId, body, accountId);
+    const successMessage = `Updated comment ${commentId}.`;
+    await callback?.({ text: successMessage, source: message.content.source });
+    return {
+      text: successMessage,
+      success: true,
+      data: { commentId: comment.id, accountId }
     };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
+  } catch (error) {
+    logger10.error("Failed to update comment:", error);
+    const errorMessage = `Failed to update comment: ${error instanceof Error ? error.message : "Unknown error"}`;
+    await callback?.({ text: errorMessage, source: message.content.source });
+    return { text: errorMessage, success: false };
+  }
+}
+
+// src/actions/updateIssue.ts
+import {
+  logger as logger11,
+  ModelType as ModelType7
+} from "@elizaos/core";
+var LINEAR_MODEL_TIMEOUT_MS2 = 15000;
+var LINEAR_LOOKUP_LIMIT = 100;
+async function handleUpdateIssue(runtime, message, _state, _options, callback) {
+  try {
+    const linearService = runtime.getService("linear");
+    if (!linearService) {
+      throw new Error("Linear service not available");
     }
-  },
-  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 update instructions for the issue.";
-        await callback?.({
-          text: errorMessage,
-          source: message.content.source
-        });
-        return {
-          text: errorMessage,
-          success: false
-        };
-      }
-      const prompt = updateIssueTemplate.replace("{{userMessage}}", content);
-      const response = await runtime.useModel(ModelType9.TEXT_LARGE, {
-        prompt
+    const accountId = getLinearAccountId(runtime, _options);
+    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) {
-        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`);
-          }
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+    const prompt = updateIssueTemplate.replace("{{userMessage}}", content);
+    const response = await Promise.race([
+      runtime.useModel(ModelType7.TEXT_LARGE, {
+        prompt
+      }),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("Linear update extraction timeout")), LINEAR_MODEL_TIMEOUT_MS2))
+    ]);
+    if (!response) {
+      throw new Error("Failed to extract update information");
+    }
+    let issueId;
+    const updates = {};
+    try {
+      const parsed = parseLinearPromptResponse(response);
+      if (Object.keys(parsed).length === 0) {
+        throw new Error("No fields found in model response");
+      }
+      issueId = getStringValue(parsed.issueId) ?? "";
+      if (!issueId) {
+        throw new Error("Issue ID not found in parsed response");
+      }
+      const parsedUpdates = getRecordValue(parsed.updates) ?? {};
+      const title = getStringValue(parsedUpdates.title);
+      if (title) {
+        updates.title = title;
+      }
+      const description = getStringValue(parsedUpdates.description);
+      if (description) {
+        updates.description = description;
+      }
+      const priority = getPriorityNumberValue(parsedUpdates.priority);
+      if (priority) {
+        updates.priority = priority;
+      }
+      const teamKey = getStringValue(parsedUpdates.teamKey);
+      if (teamKey) {
+        const teams = await linearService.getTeams(accountId);
+        const team = teams.slice(0, LINEAR_LOOKUP_LIMIT).find((t) => t.key.toLowerCase() === teamKey.toLowerCase());
+        if (team) {
+          updates.teamId = team.id;
+          logger11.info(`Moving issue to team: ${team.name} (${team.key})`);
+        } else {
+          logger11.warn(`Team with key ${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`);
-          }
+      }
+      const assignee = getStringValue(parsedUpdates.assignee);
+      if (assignee) {
+        const cleanAssignee = assignee.replace(/^@/, "");
+        const users = await linearService.getUsers(accountId);
+        const user = users.slice(0, LINEAR_LOOKUP_LIMIT).find((u) => u.email === cleanAssignee || u.name.toLowerCase().includes(cleanAssignee.toLowerCase()));
+        if (user) {
+          updates.assigneeId = user.id;
+        } else {
+          logger11.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");
+      }
+      const status = getStringValue(parsedUpdates.status);
+      if (status) {
+        const issue = await linearService.getIssue(issueId, accountId);
+        const issueTeam = await issue.team;
+        const teamId = updates.teamId || issueTeam?.id;
+        if (!teamId) {
+          logger11.warn("Could not determine team for status update");
+        } else {
+          const states = await linearService.getWorkflowStates(teamId, accountId);
+          const state = states.slice(0, LINEAR_LOOKUP_LIMIT).find((s) => s.name.toLowerCase() === status.toLowerCase() || s.type.toLowerCase() === status.toLowerCase());
+          if (state) {
+            updates.stateId = state.id;
+            logger11.info(`Changing status to: ${state.name}`);
           } 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`);
-            }
+            logger11.warn(`Status ${status} not found for team`);
           }
         }
-        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);
-              }
-            }
-          }
-          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;
+      }
+      const parsedLabels = getStringArrayValue(parsedUpdates.labels);
+      if (parsedLabels !== undefined) {
+        const teamId = updates.teamId;
+        const labels = await linearService.getLabels(teamId, accountId);
+        const labelIds = [];
+        for (const labelName of parsedLabels.slice(0, LINEAR_LOOKUP_LIMIT)) {
+          const label = labels.slice(0, LINEAR_LOOKUP_LIMIT).find((l) => l.name.toLowerCase() === labelName.toLowerCase());
+          if (label) {
+            labelIds.push(label.id);
           }
         }
+        updates.labelIds = labelIds;
       }
-      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'")`;
+    } catch (parseError) {
+      logger11.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
@@ -2473,43 +2455,28 @@ 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 = `✅ Updated issue ${updatedIssue.identifier}: ${updateSummary.join(", ")}
-
-View it at: ${updatedIssue.url}`;
-      await callback?.({
-        text: successMessage,
-        source: message.content.source
-      });
-      return {
-        text: `Updated issue ${updatedIssue.identifier}: ${updateSummary.join(", ")}`,
-        success: true,
-        data: {
-          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
+      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;
         }
-      };
-    } catch (error) {
-      logger10.error("Failed to update issue:", error);
-      const errorMessage = `❌ Failed to update issue: ${error instanceof Error ? error.message : "Unknown error"}`;
+      }
+    }
+    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: errorMessage,
         source: message.content.source
@@ -2519,14 +2486,484 @@ View it at: ${updatedIssue.url}`;
         success: false
       };
     }
+    const updatedIssue = await linearService.updateIssue(issueId, updates, accountId);
+    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(", ")}
+
+View it at: ${updatedIssue.url}`;
+    await callback?.({
+      text: successMessage,
+      source: message.content.source
+    });
+    return {
+      text: `Updated issue ${updatedIssue.identifier}: ${updateSummary.join(", ")}`,
+      success: true,
+      data: {
+        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,
+        accountId
+      }
+    };
+  } catch (error) {
+    logger11.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
+    });
+    return {
+      text: errorMessage,
+      success: false
+    };
+  }
+}
+
+// src/actions/linear.ts
+var LINEAR_CONTEXT = "linear";
+var ALL_OPS = [
+  "create_issue",
+  "get_issue",
+  "update_issue",
+  "delete_issue",
+  "create_comment",
+  "update_comment",
+  "delete_comment",
+  "list_comments",
+  "get_activity",
+  "clear_activity",
+  "search_issues"
+];
+var ROUTES = [
+  {
+    op: "delete_issue",
+    action: deleteIssueAction,
+    match: /\b(delete|archive|remove|close)\b.*\b(issue|bug|task|ticket|[a-z]+-\d+)\b/i
+  },
+  {
+    op: "update_issue",
+    run: handleUpdateIssue,
+    match: /\b(update|edit|modify|move|change|assign|reassign|priority|status|label)\b.*\b(issue|bug|task|ticket|[a-z]+-\d+)\b/i
+  },
+  {
+    op: "create_issue",
+    action: createIssueAction,
+    match: /\b(create|new|add|file|open)\b.*\b(issue|bug|task|ticket|linear)\b|\b(issue|bug|task|ticket)\b.*\b(create|new|add|file|open)\b/i
+  },
+  {
+    op: "create_comment",
+    action: createCommentAction,
+    match: /\b(comment|reply|note|tell)\b.*\b(issue|bug|task|ticket|[a-z]+-\d+)\b/i
+  },
+  {
+    op: "update_comment",
+    run: handleUpdateComment,
+    match: /\b(update|edit|modify|change)\b.*\bcomment\b/i
+  },
+  {
+    op: "delete_comment",
+    action: deleteCommentAction,
+    match: /\b(delete|remove|erase)\b.*\bcomment\b/i
+  },
+  {
+    op: "list_comments",
+    action: listCommentsAction,
+    match: /\b(list|show|get|fetch|view)\b.*\bcomments?\b|\bcomments?\b.*\b(list|show|get|fetch)\b/i
+  },
+  {
+    op: "clear_activity",
+    action: clearActivityAction,
+    match: /\b(clear|reset|delete)\b.*\b(activity|activity log)\b/i
+  },
+  {
+    op: "get_activity",
+    action: getActivityAction,
+    match: /\b(activity|activity log|what happened|recent changes|audit)\b/i
+  },
+  {
+    op: "search_issues",
+    action: searchIssuesAction,
+    match: /\b(search|find|query|list|show)\b.*\b(issues?|bugs?|tasks?|tickets?)\b|\b(open|closed|unassigned|assigned|high priority|blockers?)\b.*\b(issues?|bugs?|tasks?|tickets?)\b/i
+  },
+  {
+    op: "get_issue",
+    action: getIssueAction,
+    match: /\b(show|get|view|check|details?|status|what'?s|find)\b.*\b(issue|bug|task|ticket|[a-z]+-\d+)\b|[a-z]+-\d+/i
   }
+];
+function textOf(message) {
+  return typeof message.content?.text === "string" ? message.content.text : "";
+}
+function readOptions(options) {
+  const direct = options ?? {};
+  const parameters = direct.parameters && typeof direct.parameters === "object" ? direct.parameters : {};
+  return { ...direct, ...parameters };
+}
+function normalizeOp(value) {
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+  return ALL_OPS.includes(trimmed) ? trimmed : null;
+}
+function selectRoute(message, options) {
+  const opts = readOptions(options);
+  const requested = normalizeOp(opts.action ?? opts.subaction ?? opts.op);
+  if (requested) {
+    const route = ROUTES.find((candidate) => candidate.op === requested);
+    if (route)
+      return route;
+  }
+  const text = textOf(message);
+  return ROUTES.find((route) => route.match.test(text)) ?? null;
+}
+function hasLinearAccess(runtime) {
+  return hasLinearAccountConfig(runtime);
+}
+var linearAction = {
+  name: "LINEAR",
+  description: "Manage Linear issues, comments, and activity. Operations: create_issue, get_issue, update_issue, delete_issue, create_comment, update_comment, delete_comment, list_comments, get_activity, clear_activity, search_issues. The op is inferred from the message text when not explicitly provided.",
+  descriptionCompressed: "Linear: create/get/update/delete issue, create/update/delete/list comment, search issues, get/clear activity.",
+  similes: [
+    "LINEAR_ISSUE",
+    "LINEAR_ISSUES",
+    "LINEAR_COMMENT",
+    "LINEAR_COMMENTS",
+    "LINEAR_WORKFLOW",
+    "LINEAR_ACTIVITY",
+    "LINEAR_SEARCH",
+    "CREATE_LINEAR_ISSUE",
+    "GET_LINEAR_ISSUE",
+    "UPDATE_LINEAR_ISSUE",
+    "DELETE_LINEAR_ISSUE",
+    "MANAGE_LINEAR_ISSUE",
+    "MANAGE_LINEAR_ISSUES",
+    "CREATE_LINEAR_COMMENT",
+    "COMMENT_LINEAR_ISSUE",
+    "UPDATE_LINEAR_COMMENT",
+    "DELETE_LINEAR_COMMENT",
+    "LIST_LINEAR_COMMENTS",
+    "GET_LINEAR_ACTIVITY",
+    "CLEAR_LINEAR_ACTIVITY",
+    "SEARCH_LINEAR_ISSUES",
+    "LINEAR_WORKFLOW_SEARCH"
+  ],
+  contexts: ["general", "automation", "knowledge", LINEAR_CONTEXT],
+  contextGate: { anyOf: ["general", "automation", "knowledge", LINEAR_CONTEXT] },
+  roleGate: { minRole: "USER" },
+  parameters: [
+    {
+      name: "action",
+      description: "Operation to perform. One of: create_issue, get_issue, update_issue, delete_issue, create_comment, update_comment, delete_comment, list_comments, get_activity, clear_activity, search_issues. Inferred from message text when omitted.",
+      required: false,
+      schema: { type: "string", enum: [...ALL_OPS] }
+    },
+    linearAccountIdParameter
+  ],
+  validate: async (runtime) => {
+    if (!hasLinearAccess(runtime))
+      return false;
+    return true;
+  },
+  handler: async (runtime, message, state, options, callback) => {
+    const route = selectRoute(message, options);
+    if (!route) {
+      const ops = ALL_OPS.join(", ");
+      const text = `LINEAR could not determine the operation. Specify one of: ${ops}.`;
+      await callback?.({ text, source: message.content?.source });
+      return {
+        success: false,
+        text,
+        values: { error: "MISSING" },
+        data: { actionName: "LINEAR", availableOps: ops }
+      };
+    }
+    const dispatch = route.run ?? route.action?.handler?.bind(route.action);
+    const result = dispatch ? await dispatch(runtime, message, state, options, callback) ?? { success: true } : { success: true };
+    return {
+      ...result,
+      data: {
+        ...typeof result.data === "object" && result.data ? result.data : {},
+        actionName: "LINEAR",
+        routedActionName: route.action?.name ?? route.op,
+        op: route.op
+      }
+    };
+  },
+  examples: [
+    [
+      { name: "{{user1}}", content: { text: "Create a Linear issue for the mobile login bug" } },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I'll create that Linear issue.",
+          actions: ["LINEAR"]
+        }
+      }
+    ],
+    [
+      { name: "{{user1}}", content: { text: "Comment on ENG-123 that QA can retest it" } },
+      {
+        name: "{{agentName}}",
+        content: { text: "I'll add that comment to ENG-123.", actions: ["LINEAR"] }
+      }
+    ],
+    [
+      { name: "{{user1}}", content: { text: "Search open Linear bugs for the backend team" } },
+      {
+        name: "{{agentName}}",
+        content: { text: "I'll search Linear issues.", actions: ["LINEAR"] }
+      }
+    ],
+    [
+      { name: "{{user1}}", content: { text: "What's the status of ENG-456?" } },
+      {
+        name: "{{agentName}}",
+        content: { text: "Looking up ENG-456.", actions: ["LINEAR"] }
+      }
+    ]
+  ]
 };
 
+// src/connector-account-provider.ts
+import {
+  logger as logger12
+} from "@elizaos/core";
+var LINEAR_PROVIDER_NAME = "linear";
+var LINEAR_AUTHORIZATION_ENDPOINT = "https://linear.app/oauth/authorize";
+var LINEAR_TOKEN_ENDPOINT = "https://api.linear.app/oauth/token";
+var LINEAR_GRAPHQL_ENDPOINT = "https://api.linear.app/graphql";
+var DEFAULT_PURPOSES = ["admin"];
+function nonEmptyString2(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+function readSetting2(runtime, key) {
+  return nonEmptyString2(runtime.getSetting?.(key));
+}
+function readClientConfig(runtime) {
+  const clientId = readSetting2(runtime, "LINEAR_OAUTH_CLIENT_ID");
+  const clientSecret = readSetting2(runtime, "LINEAR_OAUTH_CLIENT_SECRET");
+  const redirectUri = readSetting2(runtime, "LINEAR_OAUTH_REDIRECT_URI");
+  if (!clientId || !clientSecret || !redirectUri) {
+    throw new Error("Linear OAuth requires LINEAR_OAUTH_CLIENT_ID, LINEAR_OAUTH_CLIENT_SECRET, and LINEAR_OAUTH_REDIRECT_URI to be configured.");
+  }
+  return { clientId, clientSecret, redirectUri };
+}
+function parseScopes(value) {
+  if (!value)
+    return [];
+  return value.split(/[,\s]+/).map((scope) => scope.trim()).filter(Boolean);
+}
+async function exchangeCodeForToken(args) {
+  const response = await fetch(LINEAR_TOKEN_ENDPOINT, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Accept: "application/json"
+    },
+    body: new URLSearchParams({
+      client_id: args.clientId,
+      client_secret: args.clientSecret,
+      code: args.code,
+      redirect_uri: args.redirectUri,
+      grant_type: "authorization_code"
+    }).toString()
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Linear token exchange failed with ${response.status}: ${body}`);
+  }
+  const parsed = await response.json();
+  if (parsed.error) {
+    throw new Error(`Linear token exchange returned error ${parsed.error}: ${parsed.error_description ?? "no description"}`);
+  }
+  if (!parsed.access_token) {
+    throw new Error("Linear token exchange returned no access_token.");
+  }
+  return parsed;
+}
+async function fetchLinearViewer(accessToken) {
+  const response = await fetch(LINEAR_GRAPHQL_ENDPOINT, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      query: "{ viewer { id name email organization { id name urlKey } } }"
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Linear viewer query failed with ${response.status}`);
+  }
+  return await response.json();
+}
+function synthesizeEnvAccounts(runtime) {
+  const now = Date.now();
+  return readLinearAccounts(runtime).map((account) => ({
+    id: account.accountId,
+    provider: LINEAR_PROVIDER_NAME,
+    label: account.label ?? `Linear (${account.accountId})`,
+    role: "OWNER",
+    purpose: DEFAULT_PURPOSES,
+    accessGate: "open",
+    status: "connected",
+    externalId: account.workspaceId,
+    displayHandle: account.workspaceId ?? account.accountId,
+    createdAt: now,
+    updatedAt: now,
+    metadata: {
+      authMethod: "api_key",
+      source: "env",
+      defaultTeamKey: account.defaultTeamKey ?? null
+    }
+  }));
+}
+function createLinearConnectorAccountProvider(runtime) {
+  return {
+    provider: LINEAR_PROVIDER_NAME,
+    label: "Linear",
+    listAccounts: async (manager) => {
+      const stored = await manager.getStorage().listAccounts(LINEAR_PROVIDER_NAME);
+      if (stored.length > 0)
+        return stored;
+      return synthesizeEnvAccounts(runtime);
+    },
+    createAccount: async (input, _manager) => {
+      return {
+        ...input,
+        provider: LINEAR_PROVIDER_NAME,
+        role: input.role ?? "OWNER",
+        purpose: input.purpose ?? DEFAULT_PURPOSES,
+        accessGate: input.accessGate ?? "open",
+        status: input.status ?? "pending"
+      };
+    },
+    patchAccount: async (_accountId, patch, _manager) => {
+      return { ...patch, provider: LINEAR_PROVIDER_NAME };
+    },
+    deleteAccount: async (_accountId, _manager) => {},
+    startOAuth: async (request, _manager) => {
+      const config = readClientConfig(runtime);
+      const redirectUri = request.redirectUri ?? config.redirectUri;
+      const scopes = request.scopes && request.scopes.length > 0 ? request.scopes : ["read", "write", "issues:create", "comments:create"];
+      const params = new URLSearchParams({
+        client_id: config.clientId,
+        redirect_uri: redirectUri,
+        response_type: "code",
+        scope: scopes.join(","),
+        state: request.flow.state,
+        prompt: "consent"
+      });
+      return {
+        authUrl: `${LINEAR_AUTHORIZATION_ENDPOINT}?${params.toString()}`,
+        metadata: {
+          ...request.metadata,
+          requestedScopes: scopes,
+          redirectUri
+        }
+      };
+    },
+    completeOAuth: async (request, _manager) => {
+      const code = nonEmptyString2(request.code);
+      if (!code) {
+        throw new Error("Linear OAuth callback is missing an authorization code.");
+      }
+      const config = readClientConfig(runtime);
+      const redirectUri = nonEmptyString2(request.flow.redirectUri) ?? config.redirectUri;
+      const tokens = await exchangeCodeForToken({
+        clientId: config.clientId,
+        clientSecret: config.clientSecret,
+        redirectUri,
+        code
+      });
+      if (!tokens.access_token) {
+        throw new Error("Linear token exchange returned no access_token.");
+      }
+      const viewerPayload = await fetchLinearViewer(tokens.access_token);
+      const viewer = viewerPayload.data?.viewer;
+      const organization = viewer?.organization;
+      const workspaceId = nonEmptyString2(organization?.id);
+      const workspaceHandle = nonEmptyString2(organization?.urlKey);
+      const externalId = workspaceId ?? workspaceHandle;
+      if (!externalId) {
+        throw new Error("Linear viewer payload did not include an organization id or urlKey.");
+      }
+      const accountPatch = {
+        provider: LINEAR_PROVIDER_NAME,
+        role: "OWNER",
+        purpose: DEFAULT_PURPOSES,
+        accessGate: "open",
+        status: "connected",
+        externalId,
+        displayHandle: workspaceHandle ?? externalId,
+        label: nonEmptyString2(organization?.name) ?? nonEmptyString2(workspaceHandle) ?? "Linear",
+        metadata: {
+          authMethod: "oauth",
+          workspaceId: workspaceId ?? null,
+          workspaceHandle: workspaceHandle ?? null,
+          workspaceName: nonEmptyString2(organization?.name) ?? null,
+          viewerId: nonEmptyString2(viewer?.id) ?? null,
+          viewerEmail: nonEmptyString2(viewer?.email) ?? null,
+          viewerName: nonEmptyString2(viewer?.name) ?? null,
+          tokenType: nonEmptyString2(tokens.token_type) ?? "bearer",
+          grantedScopes: parseScopes(tokens.scope),
+          hasRefreshToken: Boolean(tokens.refresh_token)
+        }
+      };
+      logger12.info({
+        src: "plugin:linear:connector",
+        workspaceId: workspaceId ?? null,
+        workspaceHandle: workspaceHandle ?? null
+      }, "Linear OAuth completed");
+      return {
+        account: accountPatch,
+        flow: { status: "completed" }
+      };
+    }
+  };
+}
+
 // src/providers/activity.ts
+function formatDetails(details) {
+  if (details === null || details === undefined) {
+    return "none";
+  }
+  if (Array.isArray(details)) {
+    return details.map(formatDetails).join(", ");
+  }
+  if (typeof details !== "object") {
+    return String(details);
+  }
+  return Object.entries(details).map(([key, value]) => `${key}: ${formatDetails(value)}`).join("; ");
+}
 var linearActivityProvider = {
   name: "LINEAR_ACTIVITY",
   description: "Provides context about recent Linear activity",
+  descriptionCompressed: "provide context recent Linear activity",
   dynamic: true,
+  contexts: ["automation", "connectors"],
+  contextGate: { anyOf: ["automation", "connectors"] },
+  cacheScope: "turn",
+  roleGate: { minRole: "ADMIN" },
   get: async (runtime, _message, _state) => {
     try {
       const linearService = runtime.getService("linear");
@@ -2559,7 +2996,7 @@ ${activityList.join(`
             resource_id: item.resource_id,
             success: item.success,
             error: item.error,
-            details: JSON.stringify(item.details),
+            details: formatDetails(item.details),
             timestamp: typeof item.timestamp === "string" ? item.timestamp : new Date(item.timestamp).toISOString()
           }))
         }
@@ -2576,7 +3013,12 @@ ${activityList.join(`
 var linearIssuesProvider = {
   name: "LINEAR_ISSUES",
   description: "Provides context about recent Linear issues",
+  descriptionCompressed: "provide context recent Linear issue",
   dynamic: true,
+  contexts: ["automation", "connectors"],
+  contextGate: { anyOf: ["automation", "connectors"] },
+  cacheScope: "turn",
+  roleGate: { minRole: "ADMIN" },
   get: async (runtime, _message, _state) => {
     try {
       const linearService = runtime.getService("linear");
@@ -2620,7 +3062,12 @@ ${issuesList.join(`
 var linearProjectsProvider = {
   name: "LINEAR_PROJECTS",
   description: "Provides context about active Linear projects",
+  descriptionCompressed: "provide context active Linear project",
   dynamic: true,
+  contexts: ["automation", "connectors"],
+  contextGate: { anyOf: ["automation", "connectors"] },
+  cacheScope: "agent",
+  roleGate: { minRole: "ADMIN" },
   get: async (runtime, _message, _state) => {
     try {
       const linearService = runtime.getService("linear");
@@ -2659,10 +3106,17 @@ ${projectsList.join(`
 };
 
 // src/providers/teams.ts
+var MAX_LINEAR_TEAMS = 20;
+var MAX_DESCRIPTION_CHARS = 180;
 var linearTeamsProvider = {
   name: "LINEAR_TEAMS",
   description: "Provides context about Linear teams",
+  descriptionCompressed: "provide context Linear team",
   dynamic: true,
+  contexts: ["automation", "connectors"],
+  contextGate: { anyOf: ["automation", "connectors"] },
+  cacheScope: "agent",
+  roleGate: { minRole: "ADMIN" },
   get: async (runtime, _message, _state) => {
     try {
       const linearService = runtime.getService("linear");
@@ -2672,23 +3126,25 @@ var linearTeamsProvider = {
         };
       }
       const teams = await linearService.getTeams();
+      const listedTeams = teams.slice(0, MAX_LINEAR_TEAMS);
       if (teams.length === 0) {
         return {
           text: "No Linear teams found"
         };
       }
-      const teamsList = teams.map((team) => `- ${team.name} (${team.key}): ${team.description || "No description"}`);
+      const teamsList = listedTeams.map((team) => `- ${team.name} (${team.key}): ${(team.description || "No description").slice(0, MAX_DESCRIPTION_CHARS)}`);
       const text = `Linear Teams:
 ${teamsList.join(`
 `)}`;
       return {
         text,
         data: {
-          teams: teams.map((team) => ({
+          teams: listedTeams.map((team) => ({
             id: team.id,
             name: team.name,
             key: team.key
-          }))
+          })),
+          truncated: teams.length > listedTeams.length
         }
       };
     } catch (_error) {
@@ -2699,8 +3155,85 @@ ${teamsList.join(`
   }
 };
 
+// src/search-category.ts
+var LINEAR_ISSUES_SEARCH_CATEGORY = {
+  category: "linear_issues",
+  label: "Linear issues",
+  description: "Search Linear issues by text and issue metadata filters.",
+  contexts: ["automation", "system"],
+  filters: [
+    { name: "query", label: "Query", type: "string", required: true },
+    {
+      name: "state",
+      label: "States",
+      description: "Issue workflow state names.",
+      type: "string[]"
+    },
+    {
+      name: "assignee",
+      label: "Assignees",
+      description: "Assignee names or emails.",
+      type: "string[]"
+    },
+    {
+      name: "label",
+      label: "Labels",
+      description: "Linear issue label names.",
+      type: "string[]"
+    },
+    {
+      name: "project",
+      label: "Project",
+      description: "Linear project name or identifier.",
+      type: "string"
+    },
+    {
+      name: "team",
+      label: "Team",
+      description: "Linear team key, name, or identifier.",
+      type: "string"
+    },
+    {
+      name: "priority",
+      label: "Priorities",
+      description: "Linear priorities: 1 urgent, 2 high, 3 normal, 4 low.",
+      type: "number[]"
+    },
+    {
+      name: "limit",
+      label: "Limit",
+      description: "Maximum issues to return.",
+      type: "number",
+      default: 10
+    },
+    {
+      name: "accountId",
+      label: "Account",
+      description: "Optional Linear account id. Defaults to LINEAR_DEFAULT_ACCOUNT_ID or the legacy single API key.",
+      type: "string"
+    }
+  ],
+  resultSchemaSummary: "LinearIssue[] with id, identifier, title, description, state, assignee, labels, priority, team, project, url, and updatedAt.",
+  capabilities: ["issues", "filters", "workflow", "team"],
+  source: "plugin:linear",
+  serviceType: "linear"
+};
+function hasSearchCategory(runtime, category) {
+  try {
+    runtime.getSearchCategory(category, { includeDisabled: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function registerLinearSearchCategory(runtime) {
+  if (!hasSearchCategory(runtime, LINEAR_ISSUES_SEARCH_CATEGORY.category)) {
+    runtime.registerSearchCategory(LINEAR_ISSUES_SEARCH_CATEGORY);
+  }
+}
+
 // src/services/linear.ts
-import { logger as logger11, Service } from "@elizaos/core";
+import { logger as logger13, Service } from "@elizaos/core";
 import {
   LinearClient
 } from "@linear/sdk";
@@ -2728,44 +3261,64 @@ class LinearAuthenticationError extends LinearAPIError {
 class LinearService extends Service {
   static serviceType = "linear";
   capabilityDescription = "Linear API integration for issue tracking, project management, and team collaboration";
-  client;
+  clients = new Map;
   activityLog = [];
-  linearConfig;
+  defaultAccountId = DEFAULT_LINEAR_ACCOUNT_ID;
   workspaceId;
   constructor(runtime) {
     super(runtime);
-    const apiKey = runtime?.getSetting("LINEAR_API_KEY");
-    const workspaceId = runtime?.getSetting("LINEAR_WORKSPACE_ID");
-    if (!apiKey) {
+    const accounts = runtime ? readLinearAccounts(runtime) : [];
+    const requestedDefault = runtime ? normalizeLinearAccountId(runtime.getSetting("LINEAR_DEFAULT_ACCOUNT_ID") ?? runtime.getSetting("LINEAR_ACCOUNT_ID")) : DEFAULT_LINEAR_ACCOUNT_ID;
+    const defaultAccount = resolveLinearDefaultAccount(accounts, requestedDefault);
+    if (!defaultAccount) {
       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
-    });
+    this.defaultAccountId = defaultAccount.accountId;
+    this.workspaceId = defaultAccount.workspaceId;
+    for (const account of accounts) {
+      this.clients.set(account.accountId, {
+        accountId: account.accountId,
+        config: account,
+        client: new LinearClient({ apiKey: account.apiKey })
+      });
+    }
   }
   static async start(runtime) {
     const service = new LinearService(runtime);
     await service.validateConnection();
-    logger11.info("Linear service started successfully");
+    logger13.info("Linear service started successfully");
     return service;
   }
   async stop() {
     this.activityLog = [];
-    logger11.info("Linear service stopped");
+    logger13.info("Linear service stopped");
   }
-  async validateConnection() {
+  async validateConnection(accountId) {
     try {
-      const viewer = await this.client.viewer;
-      logger11.info(`Linear connected as user: ${viewer.email}`);
+      const state = this.getAccountState(accountId);
+      const viewer = await state.client.viewer;
+      logger13.info(`Linear connected as user: ${viewer.email} (accountId=${state.accountId})`);
     } catch (_error) {
       throw new LinearAuthenticationError("Failed to authenticate with Linear API");
     }
   }
+  hasAccount(accountId) {
+    return Boolean(this.getAccountState(accountId, false));
+  }
+  getDefaultTeamKey(accountId) {
+    return this.getAccountState(accountId).config.defaultTeamKey;
+  }
+  getAccountState(accountId, throwOnMissing = true) {
+    const normalized = normalizeLinearAccountId(accountId);
+    const state = accountId ? this.clients.get(normalized) ?? null : this.clients.get(this.defaultAccountId) ?? Array.from(this.clients.values())[0] ?? null;
+    if (!state && throwOnMissing) {
+      throw new LinearAuthenticationError("Linear API key is required");
+    }
+    return state;
+  }
+  getClient(accountId) {
+    return this.getAccountState(accountId)?.client;
+  }
   logActivity(action, resourceType, resourceId, details, success, error) {
     const activity = {
       id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
@@ -2782,7 +3335,7 @@ class LinearService extends Service {
       this.activityLog = this.activityLog.slice(-1000);
     }
   }
-  getActivityLog(limit, filter) {
+  getActivityLog(limit, filter, accountId) {
     let filtered = [...this.activityLog];
     if (filter) {
       filtered = filtered.filter((item) => {
@@ -2791,25 +3344,36 @@ class LinearService extends Service {
         });
       });
     }
+    if (accountId) {
+      filtered = filtered.filter((item) => item.details.accountId === accountId);
+    }
     return filtered.slice(-(limit || 100));
   }
-  clearActivityLog() {
+  clearActivityLog(accountId) {
+    if (accountId) {
+      this.activityLog = this.activityLog.filter((item) => item.details.accountId !== accountId);
+      logger13.info(`Linear activity log cleared for accountId=${accountId}`);
+      return;
+    }
     this.activityLog = [];
-    logger11.info("Linear activity log cleared");
+    logger13.info("Linear activity log cleared");
   }
-  async getTeams() {
-    const teams = await this.client.teams();
+  async getTeams(accountId) {
+    const state = this.getAccountState(accountId);
+    const teams = await state.client.teams();
     const teamList = await teams.nodes;
-    this.logActivity("list_teams", "team", "all", { count: teamList.length }, true);
+    this.logActivity("list_teams", "team", "all", { count: teamList.length, accountId: state.accountId }, true);
     return teamList;
   }
-  async getTeam(teamId) {
-    const team = await this.client.team(teamId);
-    this.logActivity("get_team", "team", teamId, { name: team.name }, true);
+  async getTeam(teamId, accountId) {
+    const state = this.getAccountState(accountId);
+    const team = await state.client.team(teamId);
+    this.logActivity("get_team", "team", teamId, { name: team.name, accountId: state.accountId }, true);
     return team;
   }
-  async createIssue(input) {
-    const issuePayload = await this.client.createIssue({
+  async createIssue(input, accountId) {
+    const state = this.getAccountState(accountId);
+    const issuePayload = await state.client.createIssue({
       title: input.title,
       description: input.description,
       teamId: input.teamId,
@@ -2827,20 +3391,24 @@ class LinearService extends Service {
     }
     this.logActivity("create_issue", "issue", issue.id, {
       title: input.title,
-      teamId: input.teamId
+      teamId: input.teamId,
+      accountId: state.accountId
     }, true);
     return issue;
   }
-  async getIssue(issueId) {
-    const issue = await this.client.issue(issueId);
+  async getIssue(issueId, accountId) {
+    const state = this.getAccountState(accountId);
+    const issue = await state.client.issue(issueId);
     this.logActivity("get_issue", "issue", issueId, {
       title: issue.title,
-      identifier: issue.identifier
+      identifier: issue.identifier,
+      accountId: state.accountId
     }, true);
     return issue;
   }
-  async updateIssue(issueId, updates) {
-    const updatePayload = await this.client.updateIssue(issueId, {
+  async updateIssue(issueId, updates, accountId) {
+    const state = this.getAccountState(accountId);
+    const updatePayload = await state.client.updateIssue(issueId, {
       title: updates.title,
       description: updates.description,
       priority: updates.priority,
@@ -2855,18 +3423,20 @@ class LinearService extends Service {
     if (!issue) {
       throw new Error("Failed to update issue");
     }
-    this.logActivity("update_issue", "issue", issueId, updates, true);
+    this.logActivity("update_issue", "issue", issueId, { ...updates, accountId: state.accountId }, true);
     return issue;
   }
-  async deleteIssue(issueId) {
-    const archivePayload = await this.client.archiveIssue(issueId);
+  async deleteIssue(issueId, accountId) {
+    const state = this.getAccountState(accountId);
+    const archivePayload = await state.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);
+    this.logActivity("delete_issue", "issue", issueId, { action: "archived", accountId: state.accountId }, true);
   }
-  async searchIssues(filters) {
+  async searchIssues(filters, accountId) {
+    const state = this.getAccountState(accountId);
     const filterObject = {};
     if (filters.query) {
       filterObject.or = [
@@ -2875,14 +3445,14 @@ class LinearService extends Service {
       ];
     }
     if (filters.team) {
-      const teams = await this.getTeams();
+      const teams = await this.getTeams(state.accountId);
       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 users = await this.getUsers(state.accountId);
       const assigneeIds = filters.assignee.map((assigneeName) => {
         const user = users.find((u) => u.email === assigneeName || u.name.toLowerCase().includes(assigneeName.toLowerCase()));
         return user?.id;
@@ -2906,20 +3476,21 @@ class LinearService extends Service {
         }
       };
     }
-    const query = this.client.issues({
+    const query = state.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 },
+      filters: { ...filters, accountId: state.accountId },
       count: issueList.length
     }, true);
     return issueList;
   }
-  async createComment(input) {
-    const commentPayload = await this.client.createComment({
+  async createComment(input, accountId) {
+    const state = this.getAccountState(accountId);
+    const commentPayload = await state.client.createComment({
       body: input.body,
       issueId: input.issueId
     });
@@ -2929,12 +3500,39 @@ class LinearService extends Service {
     }
     this.logActivity("create_comment", "comment", comment.id, {
       issueId: input.issueId,
-      bodyLength: input.body.length
+      bodyLength: input.body.length,
+      accountId: state.accountId
     }, true);
     return comment;
   }
-  async getProjects(teamId) {
-    const query = this.client.projects({
+  async updateComment(commentId, body, accountId) {
+    const state = this.getAccountState(accountId);
+    const commentPayload = await state.client.updateComment(commentId, {
+      body
+    });
+    const comment = await commentPayload.comment;
+    if (!comment) {
+      throw new Error("Failed to update comment");
+    }
+    this.logActivity("update_comment", "comment", commentId, { bodyLength: body.length, accountId: state.accountId }, true);
+    return comment;
+  }
+  async deleteComment(commentId, accountId) {
+    const state = this.getAccountState(accountId);
+    const payload = await state.client.deleteComment(commentId);
+    if (!payload.success) {
+      throw new Error("Failed to delete comment");
+    }
+    this.logActivity("delete_comment", "comment", commentId, { accountId: state.accountId }, true);
+  }
+  async listComments(issueId, limit = 25, accountId) {
+    const issue = await this.getClient(accountId).issue(issueId);
+    const connection = await issue.comments({ first: Math.min(limit, 100) });
+    return connection.nodes;
+  }
+  async getProjects(teamId, accountId) {
+    const state = this.getAccountState(accountId);
+    const query = state.client.projects({
       first: 100
     });
     const projects = await query;
@@ -2950,44 +3548,54 @@ class LinearService extends Service {
     }
     this.logActivity("list_projects", "project", "all", {
       count: projectList.length,
-      teamId
+      teamId,
+      accountId: state.accountId
     }, true);
     return projectList;
   }
-  async getProject(projectId) {
-    const project = await this.client.project(projectId);
+  async getProject(projectId, accountId) {
+    const state = this.getAccountState(accountId);
+    const project = await state.client.project(projectId);
     this.logActivity("get_project", "project", projectId, {
-      name: project.name
+      name: project.name,
+      accountId: state.accountId
     }, true);
     return project;
   }
-  async getUsers() {
-    const users = await this.client.users();
+  async getUsers(accountId) {
+    const state = this.getAccountState(accountId);
+    const users = await state.client.users();
     const userList = await users.nodes;
     this.logActivity("list_users", "user", "all", {
-      count: userList.length
+      count: userList.length,
+      accountId: state.accountId
     }, true);
     return userList;
   }
-  async getCurrentUser() {
-    const user = await this.client.viewer;
+  async getCurrentUser(accountId) {
+    const state = this.getAccountState(accountId);
+    const user = await state.client.viewer;
     this.logActivity("get_current_user", "user", user.id, {
       email: user.email,
-      name: user.name
+      name: user.name,
+      accountId: state.accountId
     }, true);
     return user;
   }
-  async getUserTeams() {
-    const viewer = await this.client.viewer;
+  async getUserTeams(accountId) {
+    const state = this.getAccountState(accountId);
+    const viewer = await state.client.viewer;
     const teams = await viewer.teams();
     const teamList = await teams.nodes;
     this.logActivity("list_user_teams", "team", viewer.id, {
-      count: teamList.length
+      count: teamList.length,
+      accountId: state.accountId
     }, true);
     return teamList;
   }
-  async getLabels(teamId) {
-    const query = this.client.issueLabels({
+  async getLabels(teamId, accountId) {
+    const state = this.getAccountState(accountId);
+    const query = state.client.issueLabels({
       first: 100,
       filter: teamId ? {
         team: { id: { eq: teamId } }
@@ -2997,19 +3605,22 @@ class LinearService extends Service {
     const labelList = await labels.nodes;
     this.logActivity("list_labels", "label", "all", {
       count: labelList.length,
-      teamId
+      teamId,
+      accountId: state.accountId
     }, true);
     return labelList;
   }
-  async getWorkflowStates(teamId) {
-    const states = await this.client.workflowStates({
+  async getWorkflowStates(teamId, accountId) {
+    const state = this.getAccountState(accountId);
+    const states = await state.client.workflowStates({
       filter: {
         team: { id: { eq: teamId } }
       }
     });
     const stateList = await states.nodes;
     this.logActivity("list_workflow_states", "team", teamId, {
-      count: stateList.length
+      count: stateList.length,
+      accountId: state.accountId
     }, true);
     return stateList;
   }
@@ -3020,28 +3631,38 @@ var linearPlugin = {
   name: "@elizaos/plugin-linear-ts",
   description: "Plugin for integrating with Linear issue tracking system",
   services: [LinearService],
-  actions: [
-    createIssueAction,
-    getIssueAction,
-    updateIssueAction,
-    deleteIssueAction,
-    searchIssuesAction,
-    createCommentAction,
-    listTeamsAction,
-    listProjectsAction,
-    getActivityAction,
-    clearActivityAction
-  ],
+  actions: [...promoteSubactionsToActions(linearAction)],
   providers: [
     linearIssuesProvider,
     linearTeamsProvider,
     linearProjectsProvider,
     linearActivityProvider
-  ]
+  ],
+  init: async (_config, runtime) => {
+    registerLinearSearchCategory(runtime);
+    try {
+      const manager = getConnectorAccountManager(runtime);
+      manager.registerProvider(createLinearConnectorAccountProvider(runtime));
+    } catch (err) {
+      logger14.warn({
+        src: "plugin:linear",
+        err: err instanceof Error ? err.message : String(err)
+      }, "Failed to register Linear provider with ConnectorAccountManager");
+    }
+  }
 };
 export {
+  resolveLinearDefaultAccount,
+  resolveLinearAccountId,
+  resolveLinearAccount,
+  readLinearAccounts,
+  normalizeLinearAccountId,
   linearPlugin,
-  LinearService
+  hasLinearAccountConfig,
+  createLinearConnectorAccountProvider,
+  LinearService,
+  DEFAULT_LINEAR_ACCOUNT_ROLE,
+  DEFAULT_LINEAR_ACCOUNT_ID
 };
 
-//# debugId=FD61149701EB826464756E2164756E21
+//# debugId=F5689DC5E2BC1C6664756E2164756E21