@skillrecordings/cli 0.12.0 → 0.13.0

package/dist/index.js

@@ -58568,9 +58568,9 @@ var require_addComment = __commonJS({
     Object.defineProperty(exports, "__esModule", {
       value: true
     });
-    exports.default = addComment;
+    exports.default = addComment2;
     var _addComments = require_addComments();
-    function addComment(node, type, content, line) {
+    function addComment2(node, type, content, line) {
       return (0, _addComments.default)(node, type, [{
         type: line ? "CommentLine" : "CommentBlock",
         value: content
@@ -73654,7 +73654,7 @@ var require_comments = __commonJS({
     Object.defineProperty(exports, "__esModule", {
       value: true
     });
-    exports.addComment = addComment;
+    exports.addComment = addComment2;
     exports.addComments = addComments;
     exports.shareCommentsWithSiblings = shareCommentsWithSiblings;
     var _t = require_lib6();
@@ -73693,7 +73693,7 @@ var require_comments = __commonJS({
         return !set.has(el);
       });
     }
-    function addComment(type, content, line) {
+    function addComment2(type, content, line) {
       _addComment(this.node, type, content, line);
     }
     function addComments(type, comments) {
@@ -74833,7 +74833,7 @@ var SECRET_REFS = {
   QDRANT_COLLECTION: "op://Support/skill-cli/QDRANT_COLLECTION",
   OLLAMA_BASE_URL: "op://Support/skill-cli/OLLAMA_BASE_URL",
   EMBEDDING_MODEL: "op://Support/skill-cli/EMBEDDING_MODEL",
-  AGE_SECRET_KEY: "op://Support/skill-cli-age-key/password"
+  AGE_SECRET_KEY: "op://Support/skill-cli-age-key/private_key"
 };
 
 // src/core/secrets.ts
@@ -113466,6 +113466,2440 @@ function registerKbCommands(program3) {
   });
 }
 
+// src/commands/linear/index.ts
+init_esm_shims();
+
+// src/commands/linear/assign.ts
+init_esm_shims();
+
+// src/commands/linear/client.ts
+init_esm_shims();
+import { LinearClient } from "@linear/sdk";
+function getLinearClient() {
+  const apiKey = process.env.LINEAR_API_KEY;
+  if (!apiKey) {
+    throw new CLIError({
+      userMessage: "LINEAR_API_KEY environment variable is not set.",
+      suggestion: "Set LINEAR_API_KEY to your Linear API token. Get it from https://linear.app/settings/api",
+      exitCode: 1
+    });
+  }
+  return new LinearClient({ apiKey });
+}
+
+// src/commands/linear/hateoas.ts
+init_esm_shims();
+function hateoasWrap2(opts) {
+  return {
+    _type: opts.type,
+    _command: opts.command,
+    data: opts.data,
+    _links: opts.links ?? [],
+    _actions: opts.actions ?? []
+  };
+}
+function issueLinks(identifier, teamKey) {
+  const links = [
+    {
+      rel: "self",
+      command: `skill linear issue ${identifier} --json`,
+      description: "This issue"
+    },
+    {
+      rel: "comments",
+      command: `skill linear comments ${identifier} --json`,
+      description: "Comments on this issue"
+    }
+  ];
+  if (teamKey) {
+    links.push({
+      rel: "team-issues",
+      command: `skill linear issues --team ${teamKey} --json`,
+      description: "All issues in this team"
+    });
+  }
+  return links;
+}
+function issueActions(identifier) {
+  return [
+    {
+      action: "comment",
+      command: `skill linear comment ${identifier} --body "<text>"`,
+      description: "Add a comment"
+    },
+    {
+      action: "assign",
+      command: `skill linear assign ${identifier} --to <user-email>`,
+      description: "Assign this issue"
+    },
+    {
+      action: "unassign",
+      command: `skill linear assign ${identifier} --unassign`,
+      description: "Unassign this issue"
+    },
+    {
+      action: "update-state",
+      command: `skill linear state ${identifier} --state "<state-name>"`,
+      description: "Change workflow state"
+    },
+    {
+      action: "update-priority",
+      command: `skill linear update ${identifier} --priority <0-4>`,
+      description: "Change priority (0=urgent, 4=none)"
+    },
+    {
+      action: "add-label",
+      command: `skill linear label ${identifier} --add "<label-name>"`,
+      description: "Add a label"
+    },
+    {
+      action: "close",
+      command: `skill linear close ${identifier}`,
+      description: "Close this issue",
+      destructive: true
+    },
+    {
+      action: "link",
+      command: `skill linear link ${identifier} --blocks <other-id>`,
+      description: "Link to another issue"
+    }
+  ];
+}
+function issueListLinks(issues, teamKey) {
+  const links = issues.slice(0, 10).map((issue) => ({
+    rel: "issue",
+    command: `skill linear issue ${issue.identifier} --json`,
+    description: issue.title
+  }));
+  if (teamKey) {
+    links.push({
+      rel: "team",
+      command: `skill linear team ${teamKey} --json`,
+      description: "Parent team"
+    });
+  }
+  return links;
+}
+function issueListActions(teamKey) {
+  const actions = [
+    {
+      action: "create",
+      command: `skill linear create "<title>"${teamKey ? ` --team ${teamKey}` : ""}`,
+      description: "Create a new issue"
+    },
+    {
+      action: "search",
+      command: `skill linear search "<query>"`,
+      description: "Search issues"
+    },
+    {
+      action: "my-issues",
+      command: `skill linear my --json`,
+      description: "View my assigned issues"
+    }
+  ];
+  if (teamKey) {
+    actions.push({
+      action: "team-states",
+      command: `skill linear states ${teamKey} --json`,
+      description: "View workflow states"
+    });
+    actions.push({
+      action: "team-labels",
+      command: `skill linear labels ${teamKey} --json`,
+      description: "View available labels"
+    });
+  }
+  return actions;
+}
+function teamLinks(teamKey) {
+  return [
+    {
+      rel: "self",
+      command: `skill linear team ${teamKey} --json`,
+      description: "This team"
+    },
+    {
+      rel: "issues",
+      command: `skill linear issues --team ${teamKey} --json`,
+      description: "Issues in this team"
+    },
+    {
+      rel: "states",
+      command: `skill linear states ${teamKey} --json`,
+      description: "Workflow states"
+    },
+    {
+      rel: "labels",
+      command: `skill linear labels ${teamKey} --json`,
+      description: "Labels"
+    }
+  ];
+}
+function commentLinks(commentId, issueIdentifier) {
+  return [
+    {
+      rel: "issue",
+      command: `skill linear issue ${issueIdentifier} --json`,
+      description: "Parent issue"
+    },
+    {
+      rel: "all-comments",
+      command: `skill linear comments ${issueIdentifier} --json`,
+      description: "All comments"
+    }
+  ];
+}
+function userListLinks(users) {
+  return users.map((u) => ({
+    rel: "user-issues",
+    command: `skill linear issues --assignee ${u.email} --json`,
+    description: `${u.name} (${u.email})`
+  }));
+}
+
+// src/commands/linear/assign.ts
+async function assignIssue(ctx, issueId, options) {
+  if (options.to && options.unassign) {
+    throw new CLIError({
+      userMessage: "Cannot use both --to and --unassign.",
+      suggestion: "Choose one: --to <email> OR --unassign",
+      exitCode: 1
+    });
+  }
+  if (!options.to && !options.unassign) {
+    throw new CLIError({
+      userMessage: "Missing assignment option.",
+      suggestion: "Use --to <email> to assign or --unassign to remove assignee.",
+      exitCode: 1
+    });
+  }
+  try {
+    const client = getLinearClient();
+    const issue = await client.issue(issueId);
+    if (!issue) {
+      throw new CLIError({
+        userMessage: `Issue not found: ${issueId}`,
+        suggestion: "Use `skill linear issues --json` to list available issues.",
+        exitCode: 1
+      });
+    }
+    let assigneeId = null;
+    let assigneeName = null;
+    if (options.to) {
+      if (options.to.toLowerCase() === "me") {
+        const viewer = await client.viewer;
+        assigneeId = viewer.id;
+        assigneeName = viewer.name;
+      } else {
+        const users = await client.users();
+        const user = users.nodes.find(
+          (u) => u.email?.toLowerCase() === options.to.toLowerCase() || u.name?.toLowerCase() === options.to.toLowerCase()
+        );
+        if (!user) {
+          throw new CLIError({
+            userMessage: `User not found: ${options.to}`,
+            suggestion: "Use `skill linear users --json` to list available users.",
+            exitCode: 1
+          });
+        }
+        assigneeId = user.id;
+        assigneeName = user.name;
+      }
+    }
+    await client.updateIssue(issue.id, {
+      assigneeId: assigneeId || void 0
+    });
+    const team = await issue.team;
+    const resultData = {
+      issueId: issue.id,
+      issueIdentifier: issue.identifier,
+      action: options.unassign ? "unassigned" : "assigned",
+      assignee: assigneeName ? { id: assigneeId, name: assigneeName } : null,
+      success: true
+    };
+    if (ctx.format === "json") {
+      ctx.output.data(
+        JSON.stringify(
+          hateoasWrap2({
+            type: "assign-result",
+            command: `skill linear issue ${issue.identifier} --json`,
+            data: resultData,
+            links: issueLinks(issue.identifier, team?.key),
+            actions: issueActions(issue.identifier)
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    ctx.output.data("");
+    if (options.unassign) {
+      ctx.output.data(`\u2705 Unassigned ${issue.identifier}`);
+    } else {
+      ctx.output.data(`\u2705 Assigned ${issue.identifier} to ${assigneeName}`);
+    }
+    ctx.output.data("");
+    ctx.output.data(`   View: skill linear issue ${issue.identifier}`);
+    ctx.output.data("");
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to assign issue.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/close.ts
+init_esm_shims();
+async function closeIssue(ctx, issueId, options = {}) {
+  try {
+    const client = getLinearClient();
+    const issue = await client.issue(issueId);
+    if (!issue) {
+      throw new CLIError({
+        userMessage: `Issue not found: ${issueId}`,
+        suggestion: "Use `skill linear issues --json` to list available issues.",
+        exitCode: 1
+      });
+    }
+    const team = await issue.team;
+    if (!team) {
+      throw new CLIError({
+        userMessage: "Could not determine team for issue.",
+        exitCode: 1
+      });
+    }
+    const states = await team.states();
+    const targetType = options.canceled ? "canceled" : "completed";
+    const closeState = states.nodes.find((s) => s.type === targetType);
+    if (!closeState) {
+      throw new CLIError({
+        userMessage: `No ${targetType} state found for team ${team.key}.`,
+        suggestion: `Use \`skill linear states ${team.key}\` to see available states.`,
+        exitCode: 1
+      });
+    }
+    const currentState = await issue.state;
+    await client.updateIssue(issue.id, {
+      stateId: closeState.id
+    });
+    const resultData = {
+      issueId: issue.id,
+      issueIdentifier: issue.identifier,
+      previousState: currentState?.name || null,
+      newState: closeState.name,
+      closeType: targetType,
+      success: true
+    };
+    if (ctx.format === "json") {
+      ctx.output.data(
+        JSON.stringify(
+          hateoasWrap2({
+            type: "close-result",
+            command: `skill linear issue ${issue.identifier} --json`,
+            data: resultData,
+            links: [
+              ...issueLinks(issue.identifier, team.key),
+              ...teamLinks(team.key)
+            ]
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    const emoji = options.canceled ? "\u274C" : "\u2705";
+    const verb = options.canceled ? "Canceled" : "Closed";
+    ctx.output.data("");
+    ctx.output.data(`${emoji} ${verb} ${issue.identifier}`);
+    ctx.output.data("\u2500".repeat(50));
+    ctx.output.data(`   Title: ${issue.title}`);
+    ctx.output.data(`   From:  ${currentState?.name || "Unknown"}`);
+    ctx.output.data(`   To:    ${closeState.name}`);
+    ctx.output.data("");
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to close issue.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/comment.ts
+init_esm_shims();
+async function addComment(ctx, issueId, options) {
+  if (!options.body || options.body.trim().length === 0) {
+    throw new CLIError({
+      userMessage: "Comment body is required.",
+      suggestion: 'Usage: skill linear comment ENG-123 --body "Your comment"',
+      exitCode: 1
+    });
+  }
+  try {
+    const client = getLinearClient();
+    const issue = await client.issue(issueId);
+    if (!issue) {
+      throw new CLIError({
+        userMessage: `Issue not found: ${issueId}`,
+        suggestion: "Use `skill linear issues --json` to list available issues.",
+        exitCode: 1
+      });
+    }
+    const payload = await client.createComment({
+      issueId: issue.id,
+      body: options.body.trim()
+    });
+    const comment = await payload.comment;
+    if (!comment) {
+      throw new CLIError({
+        userMessage: "Failed to create comment - no comment returned.",
+        exitCode: 1
+      });
+    }
+    const user = await comment.user;
+    const commentData = {
+      id: comment.id,
+      body: comment.body,
+      issueId: issue.id,
+      issueIdentifier: issue.identifier,
+      author: user ? { id: user.id, name: user.name, email: user.email } : null,
+      createdAt: comment.createdAt,
+      url: comment.url
+    };
+    if (ctx.format === "json") {
+      ctx.output.data(
+        JSON.stringify(
+          hateoasWrap2({
+            type: "comment-created",
+            command: `skill linear comments ${issue.identifier} --json`,
+            data: commentData,
+            links: [
+              ...commentLinks(comment.id, issue.identifier),
+              ...issueLinks(issue.identifier)
+            ],
+            actions: issueActions(issue.identifier)
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    ctx.output.data("");
+    ctx.output.data(`\u2705 Comment added to ${issue.identifier}`);
+    ctx.output.data("\u2500".repeat(50));
+    ctx.output.data(`   Author:  ${user?.name || "Unknown"}`);
+    ctx.output.data(`   URL:     ${comment.url}`);
+    ctx.output.data("");
+    ctx.output.data("   Comment:");
+    ctx.output.data("   " + "-".repeat(40));
+    const bodyLines = options.body.split("\n");
+    for (const line of bodyLines.slice(0, 10)) {
+      ctx.output.data(`   ${line}`);
+    }
+    if (bodyLines.length > 10) {
+      ctx.output.data(`   ... (${bodyLines.length - 10} more lines)`);
+    }
+    ctx.output.data("");
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to add comment.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/comments.ts
+init_esm_shims();
+async function listComments(ctx, issueId, options = {}) {
+  const limit2 = options.limit || 50;
+  try {
+    const client = getLinearClient();
+    const issue = await client.issue(issueId);
+    if (!issue) {
+      throw new CLIError({
+        userMessage: `Issue not found: ${issueId}`,
+        suggestion: "Use `skill linear issues --json` to list available issues.",
+        exitCode: 1
+      });
+    }
+    const commentsConnection = await issue.comments({ first: limit2 });
+    const comments = commentsConnection.nodes || [];
+    const commentsWithUsers = await Promise.all(
+      comments.map(async (comment) => ({
+        comment,
+        user: await comment.user
+      }))
+    );
+    if (ctx.format === "json") {
+      const commentData = commentsWithUsers.map(({ comment, user }) => ({
+        id: comment.id,
+        body: comment.body,
+        author: user ? { id: user.id, name: user.name, email: user.email } : null,
+        createdAt: comment.createdAt,
+        updatedAt: comment.updatedAt,
+        url: comment.url
+      }));
+      ctx.output.data(
+        JSON.stringify(
+          hateoasWrap2({
+            type: "comment-list",
+            command: `skill linear comments ${issue.identifier} --json`,
+            data: {
+              issueId: issue.id,
+              issueIdentifier: issue.identifier,
+              issueTitle: issue.title,
+              count: comments.length,
+              comments: commentData
+            },
+            links: issueLinks(issue.identifier),
+            actions: [
+              {
+                action: "add-comment",
+                command: `skill linear comment ${issue.identifier} --body "<text>"`,
+                description: "Add a new comment"
+              },
+              ...issueActions(issue.identifier)
+            ]
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    ctx.output.data("");
+    ctx.output.data(`\u{1F4AC} Comments on ${issue.identifier}: ${issue.title}`);
+    ctx.output.data("\u2500".repeat(80));
+    if (comments.length === 0) {
+      ctx.output.data("");
+      ctx.output.data("   No comments yet.");
+      ctx.output.data("");
+      ctx.output.data(
+        `   Add one: skill linear comment ${issue.identifier} --body "Your comment"`
+      );
+      ctx.output.data("");
+      return;
+    }
+    for (const { comment, user } of commentsWithUsers) {
+      const date = new Date(comment.createdAt).toLocaleDateString();
+      const authorName = user?.name || "Unknown";
+      ctx.output.data("");
+      ctx.output.data(`   \u{1F4DD} ${authorName} \u2022 ${date}`);
+      ctx.output.data("   " + "-".repeat(40));
+      const bodyLines = comment.body.split("\n");
+      for (const line of bodyLines.slice(0, 5)) {
+        ctx.output.data(`   ${line}`);
+      }
+      if (bodyLines.length > 5) {
+        ctx.output.data(`   ... (${bodyLines.length - 5} more lines)`);
+      }
+    }
+    ctx.output.data("");
+    ctx.output.data(
+      `   Add comment: skill linear comment ${issue.identifier} --body "text"`
+    );
+    ctx.output.data("");
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to list comments.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/create.ts
+init_esm_shims();
+async function createIssue(ctx, title, options = {}) {
+  if (!title || title.trim().length === 0) {
+    throw new CLIError({
+      userMessage: "Issue title is required.",
+      suggestion: 'Usage: skill linear create "Issue title"',
+      exitCode: 1
+    });
+  }
+  try {
+    const client = getLinearClient();
+    let teamId;
+    let teamKey;
+    const teams = await client.teams();
+    if (options.team) {
+      const team = teams.nodes.find(
+        (t2) => t2.key.toLowerCase() === options.team.toLowerCase() || t2.name.toLowerCase() === options.team.toLowerCase()
+      );
+      if (!team) {
+        throw new CLIError({
+          userMessage: `Team not found: ${options.team}`,
+          suggestion: "Use `skill linear teams --json` to list available teams."
+        });
+      }
+      teamId = team.id;
+      teamKey = team.key;
+    } else {
+      const team = teams.nodes[0];
+      if (!team) {
+        throw new CLIError({
+          userMessage: "No teams found in Linear workspace.",
+          exitCode: 1
+        });
+      }
+      teamId = team.id;
+      teamKey = team.key;
+    }
+    let assigneeId;
+    if (options.assignee) {
+      if (options.assignee.toLowerCase() === "me") {
+        const viewer = await client.viewer;
+        assigneeId = viewer.id;
+      } else {
+        const users = await client.users();
+        const user = users.nodes.find(
+          (u) => u.email?.toLowerCase() === options.assignee.toLowerCase() || u.name?.toLowerCase() === options.assignee.toLowerCase()
+        );
+        if (!user) {
+          throw new CLIError({
+            userMessage: `User not found: ${options.assignee}`,
+            suggestion: "Use `skill linear users --json` to list available users."
+          });
+        }
+        assigneeId = user.id;
+      }
+    }
+    let labelIds;
+    if (options.label && options.label.length > 0) {
+      const teamLabels = await client.issueLabels({
+        filter: { team: { id: { eq: teamId } } }
+      });
+      const workspaceLabels = await client.issueLabels({
+        filter: { team: { null: true } }
+      });
+      const allLabels = [...teamLabels.nodes, ...workspaceLabels.nodes];
+      labelIds = [];
+      for (const labelName of options.label) {
+        const label = allLabels.find(
+          (l) => l.name.toLowerCase() === labelName.toLowerCase()
+        );
+        if (!label) {
+          throw new CLIError({
+            userMessage: `Label not found: ${labelName}`,
+            suggestion: `Use \`skill linear labels ${teamKey} --json\` to list available labels.`
+          });
+        }
+        labelIds.push(label.id);
+      }
+    }
+    let projectId;
+    if (options.project) {
+      const projects = await client.projects();
+      const project = projects.nodes.find(
+        (p) => p.id === options.project || p.name.toLowerCase() === options.project.toLowerCase()
+      );
+      if (!project) {
+        throw new CLIError({
+          userMessage: `Project not found: ${options.project}`,
+          suggestion: "Use `skill linear projects --json` to list available projects."
+        });
+      }
+      projectId = project.id;
+    }
+    const payload = await client.createIssue({
+      teamId,
+      title: title.trim(),
+      description: options.description,
+      priority: options.priority ?? 2,
+      assigneeId,
+      labelIds,
+      projectId,
+      estimate: options.estimate,
+      dueDate: options.dueDate
+    });
+    const issue = await payload.issue;
+    if (!issue) {
+      throw new CLIError({
+        userMessage: "Failed to create issue - no issue returned.",
+        exitCode: 1
+      });
+    }
+    const state = await issue.state;
+    const assignee = await issue.assignee;
+    const issueData = {
+      id: issue.id,
+      identifier: issue.identifier,
+      title: issue.title,
+      description: issue.description || null,
+      state: state?.name || null,
+      priority: issue.priority,
+      assignee: assignee ? { id: assignee.id, name: assignee.name, email: assignee.email } : null,
+      team: { key: teamKey },
+      url: issue.url,
+      createdAt: issue.createdAt
+    };
+    if (ctx.format === "json") {
+      ctx.output.data(
+        JSON.stringify(
+          hateoasWrap2({
+            type: "issue-created",
+            command: `skill linear issue ${issue.identifier} --json`,
+            data: issueData,
+            links: issueLinks(issue.identifier, teamKey),
+            actions: issueActions(issue.identifier)
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    ctx.output.data("");
+    ctx.output.data(`\u2705 Issue created: ${issue.identifier}`);
+    ctx.output.data("\u2500".repeat(50));
+    ctx.output.data(`   Title:    ${issue.title}`);
+    ctx.output.data(`   Team:     ${teamKey}`);
+    ctx.output.data(`   State:    ${state?.name || "Backlog"}`);
+    if (assignee) {
+      ctx.output.data(`   Assignee: ${assignee.name}`);
+    }
+    ctx.output.data(`   URL:      ${issue.url}`);
+    ctx.output.data("");
+    ctx.output.data("   Next steps:");
+    ctx.output.data(`     \u2022 View:    skill linear issue ${issue.identifier}`);
+    ctx.output.data(
+      `     \u2022 Assign:  skill linear assign ${issue.identifier} --to <email>`
+    );
+    ctx.output.data(
+      `     \u2022 Comment: skill linear comment ${issue.identifier} --body "text"`
+    );
+    ctx.output.data("");
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to create Linear issue.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/get.ts
+init_esm_shims();
+var PRIORITY_LABELS = {
+  0: "Urgent",
+  1: "High",
+  2: "Medium",
+  3: "Low",
+  4: "None"
+};
+var PRIORITY_EMOJI = {
+  0: "\u{1F534}",
+  1: "\u{1F7E0}",
+  2: "\u{1F7E1}",
+  3: "\u{1F7E2}",
+  4: "\u26AA"
+};
+async function getIssue(ctx, id) {
+  try {
+    const client = getLinearClient();
+    const issue = await client.issue(id);
+    if (!issue) {
+      throw new CLIError({
+        userMessage: `Issue ${id} not found.`,
+        suggestion: "Use `skill linear issues --json` to list available issues.",
+        exitCode: 1
+      });
+    }
+    const [state, assignee, team, labels, project, parent2, cycle] = await Promise.all([
+      issue.state,
+      issue.assignee,
+      issue.team,
+      issue.labels(),
+      issue.project,
+      issue.parent,
+      issue.cycle
+    ]);
+    const teamKey = team?.key;
+    const issueData = {
+      id: issue.id,
+      identifier: issue.identifier,
+      title: issue.title,
+      description: issue.description || null,
+      state: state?.name || null,
+      stateType: state?.type || null,
+      priority: issue.priority,
+      priorityLabel: PRIORITY_LABELS[issue.priority] || "Unknown",
+      estimate: issue.estimate || null,
+      assignee: assignee ? { id: assignee.id, name: assignee.name, email: assignee.email } : null,
+      team: team ? { id: team.id, key: team.key, name: team.name } : null,
+      project: project ? { id: project.id, name: project.name, url: project.url } : null,
+      parent: parent2 ? { id: parent2.id, identifier: parent2.identifier, title: parent2.title } : null,
+      cycle: cycle ? { id: cycle.id, name: cycle.name, number: cycle.number } : null,
+      labels: labels.nodes.map((l) => ({ id: l.id, name: l.name })),
+      url: issue.url,
+      createdAt: issue.createdAt,
+      updatedAt: issue.updatedAt,
+      completedAt: issue.completedAt || null,
+      dueDate: issue.dueDate || null
+    };
+    if (ctx.format === "json") {
+      ctx.output.data(
+        JSON.stringify(
+          hateoasWrap2({
+            type: "issue",
+            command: `skill linear issue ${issue.identifier} --json`,
+            data: issueData,
+            links: issueLinks(issue.identifier, teamKey),
+            actions: issueActions(issue.identifier)
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    ctx.output.data("");
+    ctx.output.data(
+      `${PRIORITY_EMOJI[issue.priority] || "\u26AA"} [${issue.identifier}] ${issue.title}`
+    );
+    ctx.output.data("\u2500".repeat(80));
+    ctx.output.data("");
+    ctx.output.data(`   Status:      ${state?.name || "Unknown"}`);
+    ctx.output.data(
+      `   Priority:    ${PRIORITY_LABELS[issue.priority] || "Unknown"} (${issue.priority})`
+    );
+    if (assignee) {
+      ctx.output.data(`   Assignee:    ${assignee.name} <${assignee.email}>`);
+    } else {
+      ctx.output.data(`   Assignee:    Unassigned`);
+    }
+    if (team) {
+      ctx.output.data(`   Team:        ${team.name} (${team.key})`);
+    }
+    if (project) {
+      ctx.output.data(`   Project:     ${project.name}`);
+    }
+    if (cycle) {
+      ctx.output.data(`   Cycle:       ${cycle.name}`);
+    }
+    if (parent2) {
+      ctx.output.data(`   Parent:      ${parent2.identifier} - ${parent2.title}`);
+    }
+    if (labels.nodes.length > 0) {
+      ctx.output.data(
+        `   Labels:      ${labels.nodes.map((l) => l.name).join(", ")}`
+      );
+    }
+    if (issue.estimate) {
+      ctx.output.data(`   Estimate:    ${issue.estimate} points`);
+    }
+    if (issue.dueDate) {
+      ctx.output.data(`   Due:         ${issue.dueDate}`);
+    }
+    ctx.output.data("");
+    ctx.output.data(`   URL:         ${issue.url}`);
+    ctx.output.data(
+      `   Created:     ${new Date(issue.createdAt).toLocaleDateString()}`
+    );
+    ctx.output.data(
+      `   Updated:     ${new Date(issue.updatedAt).toLocaleDateString()}`
+    );
+    if (issue.description) {
+      ctx.output.data("");
+      ctx.output.data("   Description:");
+      ctx.output.data("   " + "-".repeat(40));
+      const descLines = issue.description.split("\n");
+      for (const line of descLines.slice(0, 20)) {
+        ctx.output.data(`   ${line}`);
+      }
+      if (descLines.length > 20) {
+        ctx.output.data(`   ... (${descLines.length - 20} more lines)`);
+      }
+    }
+    ctx.output.data("");
+    ctx.output.data("   Actions:");
+    ctx.output.data(
+      `     \u2022 Comment:  skill linear comment ${issue.identifier} --body "text"`
+    );
+    ctx.output.data(
+      `     \u2022 Assign:   skill linear assign ${issue.identifier} --to <email>`
+    );
+    ctx.output.data(
+      `     \u2022 State:    skill linear state ${issue.identifier} --state "Done"`
+    );
+    ctx.output.data(`     \u2022 Close:    skill linear close ${issue.identifier}`);
+    ctx.output.data("");
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to fetch Linear issue.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/label.ts
+init_esm_shims();
+async function modifyLabels(ctx, issueId, options) {
+  const hasAdd = options.add && options.add.length > 0;
+  const hasRemove = options.remove && options.remove.length > 0;
+  if (!hasAdd && !hasRemove) {
+    throw new CLIError({
+      userMessage: "No label changes specified.",
+      suggestion: 'Use --add "Label" or --remove "Label".',
+      exitCode: 1
+    });
+  }
+  try {
+    const client = getLinearClient();
+    const issue = await client.issue(issueId);
+    if (!issue) {
+      throw new CLIError({
+        userMessage: `Issue not found: ${issueId}`,
+        suggestion: "Use `skill linear issues --json` to list available issues.",
+        exitCode: 1
+      });
+    }
+    const team = await issue.team;
+    if (!team) {
+      throw new CLIError({
+        userMessage: "Could not determine team for issue.",
+        exitCode: 1
+      });
+    }
+    const [teamLabels, workspaceLabels] = await Promise.all([
+      client.issueLabels({ filter: { team: { id: { eq: team.id } } } }),
+      client.issueLabels({ filter: { team: { null: true } } })
+    ]);
+    const allLabels = [...teamLabels.nodes, ...workspaceLabels.nodes];
+    const currentLabelsConnection = await issue.labels();
+    const currentLabelIds = new Set(
+      currentLabelsConnection.nodes.map((l) => l.id)
+    );
+    const labelsToAdd = [];
+    if (options.add) {
+      for (const labelName of options.add) {
+        const label = allLabels.find(
+          (l) => l.name.toLowerCase() === labelName.toLowerCase()
+        );
+        if (!label) {
+          throw new CLIError({
+            userMessage: `Label not found: ${labelName}`,
+            suggestion: `Use \`skill linear labels ${team.key} --json\` to list available labels.`,
+            exitCode: 1
+          });
+        }
+        if (!currentLabelIds.has(label.id)) {
+          labelsToAdd.push(label.id);
+          currentLabelIds.add(label.id);
+        }
+      }
+    }
+    const labelsToRemove = [];
+    if (options.remove) {
+      for (const labelName of options.remove) {
+        const label = currentLabelsConnection.nodes.find(
+          (l) => l.name.toLowerCase() === labelName.toLowerCase()
+        );
+        if (!label) {
+          continue;
+        }
+        labelsToRemove.push(label.id);
+        currentLabelIds.delete(label.id);
+      }
+    }
+    if (labelsToAdd.length > 0 || labelsToRemove.length > 0) {
+      await client.updateIssue(issue.id, {
+        labelIds: Array.from(currentLabelIds)
+      });
+    }
+    const updatedIssue = await client.issue(issueId);
+    const updatedLabelsConnection = await updatedIssue?.labels();
+    const updatedLabels = updatedLabelsConnection?.nodes || [];
+    const resultData = {
+      issueId: issue.id,
+      issueIdentifier: issue.identifier,
+      added: options.add || [],
+      removed: options.remove || [],
+      currentLabels: updatedLabels.map((l) => ({ id: l.id, name: l.name })),
+      success: true
+    };
+    if (ctx.format === "json") {
+      ctx.output.data(
+        JSON.stringify(
+          hateoasWrap2({
+            type: "label-result",
+            command: `skill linear issue ${issue.identifier} --json`,
+            data: resultData,
+            links: issueLinks(issue.identifier, team.key),
+            actions: issueActions(issue.identifier)
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    ctx.output.data("");
+    ctx.output.data(`\u2705 Labels updated on ${issue.identifier}`);
+    ctx.output.data("\u2500".repeat(50));
+    if (options.add && options.add.length > 0) {
+      ctx.output.data(`   Added: ${options.add.join(", ")}`);
+    }
+    if (options.remove && options.remove.length > 0) {
+      ctx.output.data(`   Removed: ${options.remove.join(", ")}`);
+    }
+    ctx.output.data("");
+    ctx.output.data(
+      `   Current labels: ${updatedLabels.length > 0 ? updatedLabels.map((l) => l.name).join(", ") : "(none)"}`
+    );
+    ctx.output.data("");
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to modify labels.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/labels.ts
+init_esm_shims();
+async function listLabels(ctx, teamKey) {
+  if (!teamKey || teamKey.trim().length === 0) {
+    throw new CLIError({
+      userMessage: "Team key is required.",
+      suggestion: "Usage: skill linear labels ENG\nUse `skill linear teams` to list teams.",
+      exitCode: 1
+    });
+  }
+  try {
+    const client = getLinearClient();
+    const teams = await client.teams();
+    const team = teams.nodes.find(
+      (t2) => t2.key.toLowerCase() === teamKey.toLowerCase() || t2.name.toLowerCase() === teamKey.toLowerCase()
+    );
+    if (!team) {
+      throw new CLIError({
+        userMessage: `Team not found: ${teamKey}`,
+        suggestion: "Use `skill linear teams --json` to list available teams.",
+        exitCode: 1
+      });
+    }
+    const [teamLabels, workspaceLabels] = await Promise.all([
+      client.issueLabels({ filter: { team: { id: { eq: team.id } } } }),
+      client.issueLabels({ filter: { team: { null: true } } })
+    ]);
+    const teamLabelNodes = teamLabels.nodes || [];
+    const workspaceLabelNodes = workspaceLabels.nodes || [];
+    if (ctx.format === "json") {
+      const labelData = {
+        team: { id: team.id, key: team.key, name: team.name },
+        teamLabels: teamLabelNodes.map((l) => ({
+          id: l.id,
+          name: l.name,
+          color: l.color,
+          description: l.description || null
+        })),
+        workspaceLabels: workspaceLabelNodes.map((l) => ({
+          id: l.id,
+          name: l.name,
+          color: l.color,
+          description: l.description || null
+        })),
+        totalCount: teamLabelNodes.length + workspaceLabelNodes.length
+      };
+      ctx.output.data(
+        JSON.stringify(
+          hateoasWrap2({
+            type: "label-list",
+            command: `skill linear labels ${team.key} --json`,
+            data: labelData,
+            links: teamLinks(team.key),
+            actions: [
+              {
+                action: "add-label",
+                command: `skill linear label <issue-id> --add "<label-name>"`,
+                description: "Add a label to an issue"
+              },
+              {
+                action: "remove-label",
+                command: `skill linear label <issue-id> --remove "<label-name>"`,
+                description: "Remove a label from an issue"
+              }
+            ]
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    ctx.output.data("");
+    ctx.output.data(`\u{1F3F7}\uFE0F  Labels for ${team.name} (${team.key})`);
+    ctx.output.data("\u2500".repeat(60));
+    if (teamLabelNodes.length > 0) {
+      ctx.output.data("");
+      ctx.output.data("   Team Labels:");
+      for (const label of teamLabelNodes) {
+        ctx.output.data(`      \u2022 ${label.name}`);
+      }
+    }
+    if (workspaceLabelNodes.length > 0) {
+      ctx.output.data("");
+      ctx.output.data("   Workspace Labels:");
+      for (const label of workspaceLabelNodes) {
+        ctx.output.data(`      \u2022 ${label.name}`);
+      }
+    }
+    if (teamLabelNodes.length === 0 && workspaceLabelNodes.length === 0) {
+      ctx.output.data("");
+      ctx.output.data("   No labels defined.");
+    }
+    ctx.output.data("");
+    ctx.output.data('   Usage: skill linear label ENG-123 --add "Bug"');
+    ctx.output.data("");
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to list labels.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/link.ts
+init_esm_shims();
+async function linkIssues(ctx, issueId, options) {
+  const relationships = [
+    { type: "blocks", value: options.blocks },
+    { type: "blocked_by", value: options.blockedBy },
+    { type: "related", value: options.related },
+    { type: "duplicate", value: options.duplicate }
+  ].filter((r) => r.value);
+  if (relationships.length === 0) {
+    throw new CLIError({
+      userMessage: "No relationship specified.",
+      suggestion: "Use --blocks, --blocked-by, --related, or --duplicate with a target issue ID.",
+      exitCode: 1
+    });
+  }
+  if (relationships.length > 1) {
+    throw new CLIError({
+      userMessage: "Only one relationship type can be specified at a time.",
+      suggestion: "Choose one: --blocks, --blocked-by, --related, or --duplicate.",
+      exitCode: 1
+    });
+  }
+  const relationship = relationships[0];
+  const targetValue = relationship.value;
+  try {
+    const client = getLinearClient();
+    const [issue, targetIssue] = await Promise.all([
+      client.issue(issueId),
+      client.issue(targetValue)
+    ]);
+    if (!issue) {
+      throw new CLIError({
+        userMessage: `Issue not found: ${issueId}`,
+        suggestion: "Use `skill linear issues --json` to list available issues.",
+        exitCode: 1
+      });
+    }
+    if (!targetIssue) {
+      throw new CLIError({
+        userMessage: `Target issue not found: ${targetValue}`,
+        suggestion: "Use `skill linear issues --json` to list available issues.",
+        exitCode: 1
+      });
+    }
+    await client.createIssueRelation({
+      issueId: issue.id,
+      relatedIssueId: targetIssue.id,
+      type: relationship.type
+    });
+    const team = await issue.team;
+    const resultData = {
+      issueId: issue.id,
+      issueIdentifier: issue.identifier,
+      targetIssueId: targetIssue.id,
+      targetIdentifier: targetIssue.identifier,
+      relationshipType: relationship.type,
+      success: true
+    };
+    if (ctx.format === "json") {
+      ctx.output.data(
+        JSON.stringify(
+          hateoasWrap2({
+            type: "link-result",
+            command: `skill linear issue ${issue.identifier} --json`,
+            data: resultData,
+            links: [
+              ...issueLinks(issue.identifier, team?.key),
+              {
+                rel: "linked-issue",
+                command: `skill linear issue ${targetIssue.identifier} --json`,
+                description: targetIssue.title
+              }
+            ],
+            actions: issueActions(issue.identifier)
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    const relationDesc = {
+      blocks: "blocks",
+      blocked_by: "is blocked by",
+      related: "is related to",
+      duplicate: "is a duplicate of"
+    }[relationship.type];
+    ctx.output.data("");
+    ctx.output.data(`\u{1F517} Link created`);
+    ctx.output.data("\u2500".repeat(50));
+    ctx.output.data(
+      `   ${issue.identifier} ${relationDesc} ${targetIssue.identifier}`
+    );
+    ctx.output.data("");
+    ctx.output.data(
+      `   View ${issue.identifier}: skill linear issue ${issue.identifier}`
+    );
+    ctx.output.data(
+      `   View ${targetIssue.identifier}: skill linear issue ${targetIssue.identifier}`
+    );
+    ctx.output.data("");
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to link issues.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/list.ts
+init_esm_shims();
+var PRIORITY_EMOJI2 = {
+  0: "\u{1F534}",
+  1: "\u{1F7E0}",
+  2: "\u{1F7E1}",
+  3: "\u{1F7E2}",
+  4: "\u26AA"
+};
+async function listIssues(ctx, options = {}) {
+  const limit2 = options.limit || 20;
+  try {
+    const client = getLinearClient();
+    const filter4 = {
+      state: {
+        type: {
+          neq: "canceled"
+        }
+      }
+    };
+    let teamKey;
+    if (options.team) {
+      const teams = await client.teams();
+      const team = teams.nodes.find(
+        (t2) => t2.key.toLowerCase() === options.team.toLowerCase() || t2.name.toLowerCase() === options.team.toLowerCase()
+      );
+      if (!team) {
+        throw new CLIError({
+          userMessage: `Team not found: ${options.team}`,
+          suggestion: "Use `skill linear teams --json` to list available teams."
+        });
+      }
+      filter4.team = { id: { eq: team.id } };
+      teamKey = team.key;
+    }
+    if (options.state) {
+      filter4.state = {
+        ...filter4.state || {},
+        name: { eqIgnoreCase: options.state }
+      };
+    }
+    if (options.assignee) {
+      if (options.assignee.toLowerCase() === "me") {
+        const viewer = await client.viewer;
+        filter4.assignee = { id: { eq: viewer.id } };
+      } else {
+        const users = await client.users();
+        const user = users.nodes.find(
+          (u) => u.email?.toLowerCase() === options.assignee.toLowerCase() || u.name?.toLowerCase() === options.assignee.toLowerCase()
+        );
+        if (!user) {
+          throw new CLIError({
+            userMessage: `User not found: ${options.assignee}`,
+            suggestion: "Use `skill linear users --json` to list available users."
+          });
+        }
+        filter4.assignee = { id: { eq: user.id } };
+      }
+    }
+    if (options.project) {
+      const projects = await client.projects();
+      const project = projects.nodes.find(
+        (p) => p.id === options.project || p.name.toLowerCase() === options.project.toLowerCase()
+      );
+      if (!project) {
+        throw new CLIError({
+          userMessage: `Project not found: ${options.project}`,
+          suggestion: "Use `skill linear projects --json` to list available projects."
+        });
+      }
+      filter4.project = { id: { eq: project.id } };
+    }
+    if (options.priority !== void 0) {
+      filter4.priority = { eq: options.priority };
+    }
+    const response = await client.issues({
+      first: limit2,
+      filter: filter4
+    });
+    const issues = response.nodes || [];
+    const issuesWithDetails = await Promise.all(
+      issues.map(async (issue) => ({
+        issue,
+        state: await issue.state,
+        assignee: await issue.assignee,
+        team: await issue.team
+      }))
+    );
+    if (ctx.format === "json") {
+      const issueData = issuesWithDetails.map(
+        ({ issue, state, assignee, team }) => ({
+          id: issue.id,
+          identifier: issue.identifier,
+          title: issue.title,
+          state: state?.name || null,
+          stateType: state?.type || null,
+          priority: issue.priority,
+          assignee: assignee ? { id: assignee.id, name: assignee.name, email: assignee.email } : null,
+          team: team ? { key: team.key, name: team.name } : null,
+          url: issue.url,
+          createdAt: issue.createdAt,
+          updatedAt: issue.updatedAt
+        })
+      );
+      ctx.output.data(
+        JSON.stringify(
+          hateoasWrap2({
+            type: "issue-list",
+            command: `skill linear issues${teamKey ? ` --team ${teamKey}` : ""} --json`,
+            data: {
+              count: issues.length,
+              issues: issueData
+            },
+            links: issueListLinks(
+              issuesWithDetails.map(({ issue }) => ({
+                identifier: issue.identifier,
+                title: issue.title
+              })),
+              teamKey
+            ),
+            actions: issueListActions(teamKey)
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    const filterDesc = [];
+    if (options.team) filterDesc.push(`team:${options.team}`);
+    if (options.state) filterDesc.push(`state:"${options.state}"`);
+    if (options.assignee) filterDesc.push(`assignee:${options.assignee}`);
+    if (options.project) filterDesc.push(`project:"${options.project}"`);
+    if (options.priority !== void 0)
+      filterDesc.push(`priority:${options.priority}`);
+    ctx.output.data("");
+    ctx.output.data(
+      `\u{1F4CB} Linear Issues (${issues.length})${filterDesc.length > 0 ? ` [${filterDesc.join(", ")}]` : ""}`
+    );
+    ctx.output.data("\u2500".repeat(80));
+    if (issues.length === 0) {
+      ctx.output.data("   No issues found matching filters.");
+      ctx.output.data("");
+      ctx.output.data("   Suggestions:");
+      ctx.output.data("     \u2022 List all issues: skill linear issues");
+      ctx.output.data('     \u2022 Create an issue: skill linear create "Title"');
+      ctx.output.data("");
+      return;
+    }
+    for (const { issue, state, assignee, team } of issuesWithDetails) {
+      const emoji = PRIORITY_EMOJI2[issue.priority] || "\u26AA";
+      const assigneeName = assignee ? `@${assignee.name}` : "";
+      const teamBadge = team ? `[${team.key}]` : "";
+      ctx.output.data("");
+      ctx.output.data(
+        `   ${emoji} ${teamBadge} ${issue.identifier}: ${issue.title}`
+      );
+      ctx.output.data(
+        `      Status: ${state?.name || "unknown"}${assigneeName ? ` | Assignee: ${assigneeName}` : ""}`
+      );
+    }
+    ctx.output.data("");
+    ctx.output.data("   Use `skill linear issue <ID> --json` for full details.");
+    ctx.output.data("");
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to list Linear issues.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/my.ts
+init_esm_shims();
+var PRIORITY_EMOJI3 = {
+  0: "\u{1F534}",
+  1: "\u{1F7E0}",
+  2: "\u{1F7E1}",
+  3: "\u{1F7E2}",
+  4: "\u26AA"
+};
+async function listMyIssues(ctx, options = {}) {
+  const limit2 = options.limit || 20;
+  try {
+    const client = getLinearClient();
+    const viewer = await client.viewer;
+    const filter4 = {
+      assignee: { id: { eq: viewer.id } },
+      state: {
+        type: {
+          nin: ["canceled", "completed"]
+        }
+      }
+    };
+    if (options.state) {
+      filter4.state = {
+        ...filter4.state || {},
+        name: { eqIgnoreCase: options.state }
+      };
+    }
+    const response = await client.issues({
+      first: limit2,
+      filter: filter4
+    });
+    const issues = response.nodes || [];
+    const issuesWithDetails = await Promise.all(
+      issues.map(async (issue) => ({
+        issue,
+        state: await issue.state,
+        team: await issue.team
+      }))
+    );
+    if (ctx.format === "json") {
+      const issueData = issuesWithDetails.map(({ issue, state, team }) => ({
+        id: issue.id,
+        identifier: issue.identifier,
+        title: issue.title,
+        state: state?.name || null,
+        stateType: state?.type || null,
+        priority: issue.priority,
+        team: team ? { key: team.key, name: team.name } : null,
+        url: issue.url,
+        createdAt: issue.createdAt,
+        updatedAt: issue.updatedAt,
+        dueDate: issue.dueDate || null
+      }));
+      ctx.output.data(
+        JSON.stringify(
+          hateoasWrap2({
+            type: "my-issues",
+            command: `skill linear my --json`,
+            data: {
+              user: {
+                id: viewer.id,
+                name: viewer.name,
+                email: viewer.email
+              },
+              count: issues.length,
+              issues: issueData
+            },
+            links: issueListLinks(
+              issuesWithDetails.map(({ issue }) => ({
+                identifier: issue.identifier,
+                title: issue.title
+              }))
+            ),
+            actions: issueListActions()
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    ctx.output.data("");
+    ctx.output.data(`\u{1F464} My Issues (${issues.length}) - ${viewer.name}`);
+    ctx.output.data("\u2500".repeat(80));
+    if (issues.length === 0) {
+      ctx.output.data("");
+      ctx.output.data("   No issues assigned to you.");
+      ctx.output.data("");
+      ctx.output.data(
+        '   Create one: skill linear create "Title" --assignee me'
+      );
+      ctx.output.data("");
+      return;
+    }
+    const byStateType = /* @__PURE__ */ new Map();
+    for (const item of issuesWithDetails) {
+      const stateType = item.state?.type || "unknown";
+      const existing = byStateType.get(stateType) || [];
+      existing.push(item);
+      byStateType.set(stateType, existing);
+    }
+    const stateOrder = ["started", "unstarted", "backlog", "triage"];
+    for (const stateType of stateOrder) {
+      const items = byStateType.get(stateType);
+      if (!items || items.length === 0) continue;
+      ctx.output.data("");
+      ctx.output.data(`   ${stateType.toUpperCase()}:`);
+      for (const { issue, state, team } of items) {
+        const emoji = PRIORITY_EMOJI3[issue.priority] || "\u26AA";
+        const teamBadge = team ? `[${team.key}]` : "";
+        const dueInfo = issue.dueDate ? ` | Due: ${issue.dueDate}` : "";
+        ctx.output.data(
+          `      ${emoji} ${teamBadge} ${issue.identifier}: ${issue.title}`
+        );
+        ctx.output.data(`         ${state?.name || "unknown"}${dueInfo}`);
+      }
+    }
+    ctx.output.data("");
+    ctx.output.data("   Use `skill linear issue <ID>` for full details.");
+    ctx.output.data("");
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to list your issues.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/projects.ts
+init_esm_shims();
+async function listProjects(ctx, options = {}) {
+  const limit2 = options.limit || 50;
+  try {
+    const client = getLinearClient();
+    const response = await client.projects({
+      first: limit2
+    });
+    const projects = response.nodes || [];
+    if (ctx.format === "json") {
+      ctx.output.data(
+        JSON.stringify(
+          {
+            success: true,
+            count: projects.length,
+            projects: projects.map((project) => ({
+              id: project.id,
+              name: project.name,
+              description: project.description,
+              state: project.state,
+              url: project.url
+            }))
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    ctx.output.data(`
+\u{1F4C1} Linear Projects (${projects.length}):`);
+    ctx.output.data("-".repeat(80));
+    if (projects.length === 0) {
+      ctx.output.data("   No projects found.");
+    } else {
+      for (const project of projects) {
+        const stateIcon = project.state === "completed" ? "\u2713" : "\u25CF";
+        ctx.output.data(`   ${stateIcon} ${project.name}`);
+        ctx.output.data(`      ID: ${project.id}`);
+        ctx.output.data(`      State: ${project.state}`);
+        if (project.description) {
+          const truncatedDesc = project.description.length > 60 ? project.description.slice(0, 60) + "..." : project.description;
+          ctx.output.data(`      Desc: ${truncatedDesc}`);
+        }
+        ctx.output.data("");
+      }
+    }
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to list Linear projects.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/search.ts
+init_esm_shims();
+var PRIORITY_EMOJI4 = {
+  0: "\u{1F534}",
+  1: "\u{1F7E0}",
+  2: "\u{1F7E1}",
+  3: "\u{1F7E2}",
+  4: "\u26AA"
+};
+async function searchIssues(ctx, query, options = {}) {
+  if (!query || query.trim().length === 0) {
+    throw new CLIError({
+      userMessage: "Search query is required.",
+      suggestion: 'Usage: skill linear search "your query"',
+      exitCode: 1
+    });
+  }
+  const limit2 = options.limit || 20;
+  try {
+    const client = getLinearClient();
+    const response = await client.searchIssues(query.trim(), {
+      first: limit2
+    });
+    const issues = response.nodes || [];
+    const issuesWithDetails = await Promise.all(
+      issues.map(async (issue) => ({
+        issue,
+        state: await issue.state,
+        assignee: await issue.assignee,
+        team: await issue.team
+      }))
+    );
+    if (ctx.format === "json") {
+      const issueData = issuesWithDetails.map(
+        ({ issue, state, assignee, team }) => ({
+          id: issue.id,
+          identifier: issue.identifier,
+          title: issue.title,
+          state: state?.name || null,
+          priority: issue.priority,
+          assignee: assignee ? { id: assignee.id, name: assignee.name, email: assignee.email } : null,
+          team: team ? { key: team.key, name: team.name } : null,
+          url: issue.url
+        })
+      );
+      ctx.output.data(
+        JSON.stringify(
+          hateoasWrap2({
+            type: "search-results",
+            command: `skill linear search "${query}" --json`,
+            data: {
+              query,
+              count: issues.length,
+              issues: issueData
+            },
+            links: issueListLinks(
+              issuesWithDetails.map(({ issue }) => ({
+                identifier: issue.identifier,
+                title: issue.title
+              }))
+            ),
+            actions: issueListActions()
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    ctx.output.data("");
+    ctx.output.data(`\u{1F50D} Search: "${query}" (${issues.length} results)`);
+    ctx.output.data("\u2500".repeat(80));
+    if (issues.length === 0) {
+      ctx.output.data("");
+      ctx.output.data("   No issues found matching your search.");
+      ctx.output.data("");
+      ctx.output.data("   Try:");
+      ctx.output.data("     \u2022 Different keywords");
+      ctx.output.data("     \u2022 skill linear issues (list all)");
+      ctx.output.data("     \u2022 skill linear my (your assigned issues)");
+      ctx.output.data("");
+      return;
+    }
+    for (const { issue, state, assignee, team } of issuesWithDetails) {
+      const emoji = PRIORITY_EMOJI4[issue.priority] || "\u26AA";
+      const teamBadge = team ? `[${team.key}]` : "";
+      ctx.output.data("");
+      ctx.output.data(
+        `   ${emoji} ${teamBadge} ${issue.identifier}: ${issue.title}`
+      );
+      ctx.output.data(
+        `      Status: ${state?.name || "unknown"}${assignee ? ` | @${assignee.name}` : ""}`
+      );
+    }
+    ctx.output.data("");
+    ctx.output.data("   Use `skill linear issue <ID>` for full details.");
+    ctx.output.data("");
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to search issues.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/state.ts
+init_esm_shims();
+async function changeState(ctx, issueId, options) {
+  if (!options.state || options.state.trim().length === 0) {
+    throw new CLIError({
+      userMessage: "State name is required.",
+      suggestion: 'Usage: skill linear state ENG-123 --state "In Progress"',
+      exitCode: 1
+    });
+  }
+  try {
+    const client = getLinearClient();
+    const issue = await client.issue(issueId);
+    if (!issue) {
+      throw new CLIError({
+        userMessage: `Issue not found: ${issueId}`,
+        suggestion: "Use `skill linear issues --json` to list available issues.",
+        exitCode: 1
+      });
+    }
+    const team = await issue.team;
+    if (!team) {
+      throw new CLIError({
+        userMessage: "Could not determine team for issue.",
+        exitCode: 1
+      });
+    }
+    const states = await team.states();
+    const targetState = states.nodes.find(
+      (s) => s.name.toLowerCase() === options.state.toLowerCase()
+    );
+    if (!targetState) {
+      const availableStates = states.nodes.map((s) => s.name).join(", ");
+      throw new CLIError({
+        userMessage: `State not found: ${options.state}`,
+        suggestion: `Available states for ${team.key}: ${availableStates}`,
+        exitCode: 1
+      });
+    }
+    const currentState = await issue.state;
+    await client.updateIssue(issue.id, {
+      stateId: targetState.id
+    });
+    const resultData = {
+      issueId: issue.id,
+      issueIdentifier: issue.identifier,
+      previousState: currentState?.name || null,
+      newState: targetState.name,
+      stateType: targetState.type,
+      success: true
+    };
+    if (ctx.format === "json") {
+      ctx.output.data(
+        JSON.stringify(
+          hateoasWrap2({
+            type: "state-change-result",
+            command: `skill linear issue ${issue.identifier} --json`,
+            data: resultData,
+            links: issueLinks(issue.identifier, team.key),
+            actions: issueActions(issue.identifier)
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    ctx.output.data("");
+    ctx.output.data(`\u2705 ${issue.identifier} state changed`);
+    ctx.output.data("\u2500".repeat(50));
+    ctx.output.data(`   From: ${currentState?.name || "Unknown"}`);
+    ctx.output.data(`   To:   ${targetState.name}`);
+    ctx.output.data("");
+    ctx.output.data(`   View: skill linear issue ${issue.identifier}`);
+    ctx.output.data("");
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to change state.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/states.ts
+init_esm_shims();
+var STATE_TYPE_EMOJI = {
+  backlog: "\u{1F4CB}",
+  unstarted: "\u26AA",
+  started: "\u{1F535}",
+  completed: "\u2705",
+  canceled: "\u274C",
+  triage: "\u{1F4E5}"
+};
+async function listStates(ctx, teamKey) {
+  if (!teamKey || teamKey.trim().length === 0) {
+    throw new CLIError({
+      userMessage: "Team key is required.",
+      suggestion: "Usage: skill linear states ENG\nUse `skill linear teams` to list teams.",
+      exitCode: 1
+    });
+  }
+  try {
+    const client = getLinearClient();
+    const teams = await client.teams();
+    const team = teams.nodes.find(
+      (t2) => t2.key.toLowerCase() === teamKey.toLowerCase() || t2.name.toLowerCase() === teamKey.toLowerCase()
+    );
+    if (!team) {
+      throw new CLIError({
+        userMessage: `Team not found: ${teamKey}`,
+        suggestion: "Use `skill linear teams --json` to list available teams.",
+        exitCode: 1
+      });
+    }
+    const statesConnection = await team.states();
+    const states = statesConnection.nodes || [];
+    const sortedStates = [...states].sort((a, b) => a.position - b.position);
+    if (ctx.format === "json") {
+      const stateData = sortedStates.map((state) => ({
+        id: state.id,
+        name: state.name,
+        type: state.type,
+        color: state.color,
+        position: state.position,
+        description: state.description || null
+      }));
+      ctx.output.data(
+        JSON.stringify(
+          hateoasWrap2({
+            type: "state-list",
+            command: `skill linear states ${team.key} --json`,
+            data: {
+              team: { id: team.id, key: team.key, name: team.name },
+              count: states.length,
+              states: stateData
+            },
+            links: teamLinks(team.key),
+            actions: [
+              {
+                action: "change-issue-state",
+                command: `skill linear state <issue-id> --state "<state-name>"`,
+                description: "Change an issue to this state"
+              }
+            ]
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    ctx.output.data("");
+    ctx.output.data(`\u{1F4CA} Workflow States for ${team.name} (${team.key})`);
+    ctx.output.data("\u2500".repeat(60));
+    const typeOrder = [
+      "triage",
+      "backlog",
+      "unstarted",
+      "started",
+      "completed",
+      "canceled"
+    ];
+    const statesByType = /* @__PURE__ */ new Map();
+    for (const state of sortedStates) {
+      const existing = statesByType.get(state.type) || [];
+      existing.push(state);
+      statesByType.set(state.type, existing);
+    }
+    for (const type of typeOrder) {
+      const typeStates = statesByType.get(type);
+      if (!typeStates || typeStates.length === 0) continue;
+      const emoji = STATE_TYPE_EMOJI[type] || "\u{1F4CC}";
+      ctx.output.data("");
+      ctx.output.data(`   ${emoji} ${type.toUpperCase()}`);
+      for (const state of typeStates) {
+        ctx.output.data(`      \u2022 ${state.name}`);
+      }
+    }
+    ctx.output.data("");
+    ctx.output.data(
+      '   Usage: skill linear state ENG-123 --state "In Progress"'
+    );
+    ctx.output.data("");
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to list states.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/teams.ts
+init_esm_shims();
+async function listTeams(ctx, options = {}) {
+  try {
+    const client = getLinearClient();
+    const response = await client.teams();
+    const teams = response.nodes || [];
+    if (ctx.format === "json") {
+      ctx.output.data(
+        JSON.stringify(
+          {
+            success: true,
+            count: teams.length,
+            teams: teams.map((team) => ({
+              id: team.id,
+              key: team.key,
+              name: team.name,
+              description: team.description
+            }))
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    ctx.output.data(`
+\u{1F465} Linear Teams (${teams.length}):`);
+    ctx.output.data("-".repeat(80));
+    if (teams.length === 0) {
+      ctx.output.data("   No teams found.");
+    } else {
+      for (const team of teams) {
+        ctx.output.data(`   ${team.key} - ${team.name}`);
+        ctx.output.data(`      ID: ${team.id}`);
+        if (team.description) {
+          ctx.output.data(`      Desc: ${team.description}`);
+        }
+        ctx.output.data("");
+      }
+    }
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to list Linear teams.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/update.ts
+init_esm_shims();
+async function updateIssue(ctx, issueId, options) {
+  const hasUpdate = Object.values(options).some((v) => v !== void 0);
+  if (!hasUpdate) {
+    throw new CLIError({
+      userMessage: "No updates specified.",
+      suggestion: "Use --title, --description, --priority, --estimate, --due-date, or --project.",
+      exitCode: 1
+    });
+  }
+  try {
+    const client = getLinearClient();
+    const issue = await client.issue(issueId);
+    if (!issue) {
+      throw new CLIError({
+        userMessage: `Issue not found: ${issueId}`,
+        suggestion: "Use `skill linear issues --json` to list available issues.",
+        exitCode: 1
+      });
+    }
+    const updatePayload = {};
+    if (options.title) {
+      updatePayload.title = options.title;
+    }
+    if (options.description !== void 0) {
+      updatePayload.description = options.description;
+    }
+    if (options.priority !== void 0) {
+      if (options.priority < 0 || options.priority > 4) {
+        throw new CLIError({
+          userMessage: "Invalid priority value.",
+          suggestion: "Priority must be 0-4: 0=Urgent, 1=High, 2=Medium, 3=Low, 4=None",
+          exitCode: 1
+        });
+      }
+      updatePayload.priority = options.priority;
+    }
+    if (options.estimate !== void 0) {
+      updatePayload.estimate = options.estimate;
+    }
+    if (options.dueDate !== void 0) {
+      updatePayload.dueDate = options.dueDate;
+    }
+    if (options.project) {
+      const projects = await client.projects();
+      const project = projects.nodes.find(
+        (p) => p.id === options.project || p.name.toLowerCase() === options.project.toLowerCase()
+      );
+      if (!project) {
+        throw new CLIError({
+          userMessage: `Project not found: ${options.project}`,
+          suggestion: "Use `skill linear projects --json` to list available projects.",
+          exitCode: 1
+        });
+      }
+      updatePayload.projectId = project.id;
+    }
+    await client.updateIssue(issue.id, updatePayload);
+    const updatedIssue = await client.issue(issueId);
+    const [state, assignee, team] = await Promise.all([
+      updatedIssue?.state,
+      updatedIssue?.assignee,
+      updatedIssue?.team
+    ]);
+    const changes = Object.keys(options).filter(
+      (k) => options[k] !== void 0
+    );
+    const resultData = {
+      issueId: issue.id,
+      issueIdentifier: issue.identifier,
+      changes,
+      updated: {
+        title: updatedIssue?.title,
+        description: updatedIssue?.description || null,
+        priority: updatedIssue?.priority,
+        estimate: updatedIssue?.estimate || null,
+        dueDate: updatedIssue?.dueDate || null,
+        state: state?.name || null,
+        assignee: assignee ? { id: assignee.id, name: assignee.name } : null
+      },
+      success: true
+    };
+    if (ctx.format === "json") {
+      ctx.output.data(
+        JSON.stringify(
+          hateoasWrap2({
+            type: "update-result",
+            command: `skill linear issue ${issue.identifier} --json`,
+            data: resultData,
+            links: issueLinks(issue.identifier, team?.key),
+            actions: issueActions(issue.identifier)
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    ctx.output.data("");
+    ctx.output.data(`\u2705 Updated ${issue.identifier}`);
+    ctx.output.data("\u2500".repeat(50));
+    for (const change of changes) {
+      const value = options[change];
+      ctx.output.data(`   ${change}: ${value}`);
+    }
+    ctx.output.data("");
+    ctx.output.data(`   View: skill linear issue ${issue.identifier}`);
+    ctx.output.data("");
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to update issue.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/users.ts
+init_esm_shims();
+async function listUsers(ctx) {
+  try {
+    const client = getLinearClient();
+    const usersConnection = await client.users();
+    const users = usersConnection.nodes || [];
+    const activeUsers = users.filter((u) => u.active);
+    if (ctx.format === "json") {
+      const userData = activeUsers.map((user) => ({
+        id: user.id,
+        name: user.name,
+        displayName: user.displayName,
+        email: user.email,
+        admin: user.admin,
+        active: user.active,
+        avatarUrl: user.avatarUrl || null
+      }));
+      ctx.output.data(
+        JSON.stringify(
+          hateoasWrap2({
+            type: "user-list",
+            command: `skill linear users --json`,
+            data: {
+              count: activeUsers.length,
+              users: userData
+            },
+            links: userListLinks(
+              activeUsers.map((u) => ({
+                id: u.id,
+                email: u.email || "",
+                name: u.name
+              }))
+            ),
+            actions: [
+              {
+                action: "assign-to-user",
+                command: `skill linear assign <issue-id> --to "<email>"`,
+                description: "Assign an issue to this user"
+              },
+              {
+                action: "filter-by-user",
+                command: `skill linear issues --assignee "<email>" --json`,
+                description: "View user's assigned issues"
+              }
+            ]
+          }),
+          null,
+          2
+        )
+      );
+      return;
+    }
+    ctx.output.data("");
+    ctx.output.data(`\u{1F465} Workspace Users (${activeUsers.length})`);
+    ctx.output.data("\u2500".repeat(60));
+    for (const user of activeUsers) {
+      const adminBadge = user.admin ? " [Admin]" : "";
+      ctx.output.data("");
+      ctx.output.data(`   ${user.name}${adminBadge}`);
+      ctx.output.data(`      Email: ${user.email || "(no email)"}`);
+    }
+    ctx.output.data("");
+    ctx.output.data(
+      '   Assign: skill linear assign ENG-123 --to "email@example.com"'
+    );
+    ctx.output.data("");
+  } catch (error) {
+    const cliError = error instanceof CLIError ? error : new CLIError({
+      userMessage: "Failed to list users.",
+      suggestion: "Verify LINEAR_API_KEY is set correctly.",
+      cause: error
+    });
+    ctx.output.error(formatError(cliError));
+    process.exitCode = cliError.exitCode;
+  }
+}
+
+// src/commands/linear/index.ts
+async function contextFromCommand2(command, options) {
+  const opts = typeof command.optsWithGlobals === "function" ? command.optsWithGlobals() : {
+    ...command.parent?.opts(),
+    ...command.opts()
+  };
+  return createContext({
+    format: options.json ? "json" : opts.format,
+    verbose: opts.verbose,
+    quiet: opts.quiet
+  });
+}
+function registerLinearCommands(program3) {
+  const linear = program3.command("linear").description(
+    `Linear issue tracking commands
+
+Quick start:
+  skill linear my                    Your assigned issues
+  skill linear issues --team ENG     Team's issues
+  skill linear create "Title"        Create issue
+  skill linear search "query"        Search issues
+
+All commands support --json for machine-readable output.`
+  );
+  linear.command("issues").description(
+    `List issues with optional filters
+
+Examples:
+  skill linear issues                         All recent issues
+  skill linear issues --team ENG              Filter by team
+  skill linear issues --state "In Progress"   Filter by state
+  skill linear issues --assignee me           Your issues
+  skill linear issues --priority 0            Urgent only`
+  ).option("--limit <number>", "Maximum results (default: 20)", "20").option("--team <key>", "Filter by team key (e.g., ENG)").option("--state <name>", "Filter by state name").option("--assignee <email>", 'Filter by assignee (or "me")').option("--project <name>", "Filter by project name").option("--priority <0-4>", "Filter by priority (0=urgent)").option("--json", "Output as JSON with HATEOAS links").action(async (options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await listIssues(ctx, {
+      limit: parseInt(options.limit || "20", 10),
+      team: options.team,
+      state: options.state,
+      assignee: options.assignee,
+      project: options.project,
+      priority: options.priority !== void 0 ? parseInt(options.priority, 10) : void 0
+    });
+  });
+  linear.command("my").description(
+    `List your assigned issues (excludes completed/canceled)
+
+Examples:
+  skill linear my                     All your open issues
+  skill linear my --state "In Progress"  Only in-progress
+  skill linear my --limit 5           Just top 5`
+  ).option("--limit <number>", "Maximum results (default: 20)", "20").option("--state <name>", "Filter by state name").option("--json", "Output as JSON with HATEOAS links").action(async (options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await listMyIssues(ctx, {
+      limit: parseInt(options.limit || "20", 10),
+      state: options.state
+    });
+  });
+  linear.command("search").description(
+    `Search issues by text
+
+Examples:
+  skill linear search "authentication bug"
+  skill linear search "login" --limit 10
+  skill linear search "error" --json`
+  ).argument("<query>", "Search query").option("--limit <number>", "Maximum results (default: 20)", "20").option("--json", "Output as JSON with HATEOAS links").action(async (query, options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await searchIssues(ctx, query, {
+      limit: parseInt(options.limit || "20", 10)
+    });
+  });
+  linear.command("issue").description(
+    `Get detailed info about an issue
+
+Examples:
+  skill linear issue ENG-123
+  skill linear issue ENG-123 --json`
+  ).argument("<id>", "Issue identifier (e.g., ENG-123)").option("--json", "Output as JSON with HATEOAS links").action(async (id, options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await getIssue(ctx, id);
+  });
+  linear.command("create").description(
+    `Create a new issue
+
+Examples:
+  skill linear create "Fix login bug"
+  skill linear create "Title" --team ENG --priority 1
+  skill linear create "Task" --assignee me --label "Frontend"
+
+Priority: 0=Urgent, 1=High, 2=Medium, 3=Low, 4=None`
+  ).argument("<title>", "Issue title").option("--description <text>", "Issue description (markdown)").option("--team <key>", "Team key (defaults to first team)").option("--priority <0-4>", "Priority level", "2").option("--assignee <email>", 'Assignee email (or "me")').option(
+    "--label <name>",
+    "Add label (repeatable)",
+    (v, p) => [...p, v],
+    []
+  ).option("--project <name>", "Project name").option("--estimate <points>", "Estimate in points").option("--due-date <YYYY-MM-DD>", "Due date").option("--json", "Output as JSON with HATEOAS links").action(async (title, options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await createIssue(ctx, title, {
+      description: options.description,
+      priority: parseInt(options.priority || "2", 10),
+      team: options.team,
+      label: options.label,
+      assignee: options.assignee,
+      project: options.project,
+      estimate: options.estimate ? parseInt(options.estimate, 10) : void 0,
+      dueDate: options.dueDate
+    });
+  });
+  linear.command("update").description(
+    `Update issue properties
+
+Examples:
+  skill linear update ENG-123 --title "New title"
+  skill linear update ENG-123 --priority 1 --estimate 3
+  skill linear update ENG-123 --due-date 2024-03-15`
+  ).argument("<id>", "Issue identifier").option("--title <text>", "New title").option("--description <text>", "New description").option("--priority <0-4>", "New priority").option("--estimate <points>", "New estimate").option("--due-date <YYYY-MM-DD>", "New due date").option("--project <name>", "Move to project").option("--json", "Output as JSON with HATEOAS links").action(async (id, options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await updateIssue(ctx, id, {
+      title: options.title,
+      description: options.description,
+      priority: options.priority !== void 0 ? parseInt(options.priority, 10) : void 0,
+      estimate: options.estimate !== void 0 ? parseInt(options.estimate, 10) : void 0,
+      dueDate: options.dueDate,
+      project: options.project
+    });
+  });
+  linear.command("assign").description(
+    `Assign or unassign an issue
+
+Examples:
+  skill linear assign ENG-123 --to user@example.com
+  skill linear assign ENG-123 --to me
+  skill linear assign ENG-123 --unassign`
+  ).argument("<id>", "Issue identifier").option("--to <email>", 'Assign to user email (or "me")').option("--unassign", "Remove assignee").option("--json", "Output as JSON with HATEOAS links").action(async (id, options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await assignIssue(ctx, id, {
+      to: options.to,
+      unassign: options.unassign
+    });
+  });
+  linear.command("state").description(
+    `Change issue workflow state
+
+Examples:
+  skill linear state ENG-123 --state "In Progress"
+  skill linear state ENG-123 --state "Done"
+
+Use 'skill linear states <team>' to see available states.`
+  ).argument("<id>", "Issue identifier").requiredOption("--state <name>", "Target state name").option("--json", "Output as JSON with HATEOAS links").action(async (id, options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await changeState(ctx, id, { state: options.state });
+  });
+  linear.command("close").description(
+    `Close an issue (mark as done or canceled)
+
+Examples:
+  skill linear close ENG-123              Close as done
+  skill linear close ENG-123 --canceled   Cancel the issue`
+  ).argument("<id>", "Issue identifier").option("--canceled", "Close as canceled instead of done").option("--json", "Output as JSON with HATEOAS links").action(async (id, options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await closeIssue(ctx, id, { canceled: options.canceled });
+  });
+  linear.command("label").description(
+    `Add or remove labels from an issue
+
+Examples:
+  skill linear label ENG-123 --add "Bug"
+  skill linear label ENG-123 --add "Bug" --add "Frontend"
+  skill linear label ENG-123 --remove "WIP"
+
+Use 'skill linear labels <team>' to see available labels.`
+  ).argument("<id>", "Issue identifier").option(
+    "--add <name>",
+    "Add label (repeatable)",
+    (v, p) => [...p, v],
+    []
+  ).option(
+    "--remove <name>",
+    "Remove label (repeatable)",
+    (v, p) => [...p, v],
+    []
+  ).option("--json", "Output as JSON with HATEOAS links").action(async (id, options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await modifyLabels(ctx, id, {
+      add: options.add,
+      remove: options.remove
+    });
+  });
+  linear.command("link").description(
+    `Link issues together (dependencies, relations)
+
+Examples:
+  skill linear link ENG-123 --blocks ENG-456
+  skill linear link ENG-123 --blocked-by ENG-456
+  skill linear link ENG-123 --related ENG-456
+  skill linear link ENG-123 --duplicate ENG-456`
+  ).argument("<id>", "Source issue identifier").option("--blocks <id>", "This issue blocks <id>").option("--blocked-by <id>", "This issue is blocked by <id>").option("--related <id>", "Related to <id>").option("--duplicate <id>", "Duplicate of <id>").option("--json", "Output as JSON with HATEOAS links").action(async (id, options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await linkIssues(ctx, id, {
+      blocks: options.blocks,
+      blockedBy: options.blockedBy,
+      related: options.related,
+      duplicate: options.duplicate
+    });
+  });
+  linear.command("comment").description(
+    `Add a comment to an issue
+
+Examples:
+  skill linear comment ENG-123 --body "Great work!"
+  skill linear comment ENG-123 --body "## Update\\n- Item 1\\n- Item 2"`
+  ).argument("<id>", "Issue identifier").requiredOption("--body <text>", "Comment text (supports markdown)").option("--json", "Output as JSON with HATEOAS links").action(async (id, options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await addComment(ctx, id, { body: options.body });
+  });
+  linear.command("comments").description(
+    `List comments on an issue
+
+Examples:
+  skill linear comments ENG-123
+  skill linear comments ENG-123 --limit 10 --json`
+  ).argument("<id>", "Issue identifier").option("--limit <number>", "Maximum results (default: 50)", "50").option("--json", "Output as JSON with HATEOAS links").action(async (id, options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await listComments(ctx, id, {
+      limit: parseInt(options.limit || "50", 10)
+    });
+  });
+  linear.command("teams").description(
+    `List all teams in your workspace
+
+Examples:
+  skill linear teams
+  skill linear teams --json`
+  ).option("--json", "Output as JSON with HATEOAS links").action(async (options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await listTeams(ctx);
+  });
+  linear.command("states").description(
+    `List workflow states for a team
+
+Examples:
+  skill linear states ENG
+  skill linear states "Product" --json`
+  ).argument("<team>", "Team key or name").option("--json", "Output as JSON with HATEOAS links").action(async (team, options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await listStates(ctx, team);
+  });
+  linear.command("labels").description(
+    `List labels for a team
+
+Examples:
+  skill linear labels ENG
+  skill linear labels ENG --json`
+  ).argument("<team>", "Team key or name").option("--json", "Output as JSON with HATEOAS links").action(async (team, options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await listLabels(ctx, team);
+  });
+  linear.command("users").description(
+    `List workspace users
+
+Examples:
+  skill linear users
+  skill linear users --json`
+  ).option("--json", "Output as JSON with HATEOAS links").action(async (options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await listUsers(ctx);
+  });
+  linear.command("projects").description(
+    `List all projects
+
+Examples:
+  skill linear projects
+  skill linear projects --limit 100 --json`
+  ).option("--limit <number>", "Maximum results (default: 50)", "50").option("--json", "Output as JSON with HATEOAS links").action(async (options, command) => {
+    const ctx = await contextFromCommand2(command, options);
+    await listProjects(ctx, { limit: parseInt(options.limit || "50", 10) });
+  });
+}
+
 // src/commands/memory/index.ts
 init_esm_shims();
 
@@ -117139,6 +119573,7 @@ registerDatasetCommands(program2);
 registerResponseCommands(program2);
 registerToolsCommands(program2);
 registerMemoryCommands(program2);
+registerLinearCommands(program2);
 registerFaqCommands(program2);
 registerDeployCommands(program2);
 registerKbCommands(program2);