@skillrecordings/cli 0.11.2 → 0.13.0

package/dist/index.js

@@ -19837,8 +19837,8 @@ var require_snapshot_recorder = __commonJS({
   "../../node_modules/.bun/undici@7.20.0/node_modules/undici/lib/mock/snapshot-recorder.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var { writeFile: writeFile7, readFile: readFile10, mkdir: mkdir2 } = __require("fs/promises");
-    var { dirname: dirname4, resolve: resolve7 } = __require("path");
+    var { writeFile: writeFile9, readFile: readFile10, mkdir: mkdir2 } = __require("fs/promises");
+    var { dirname: dirname6, resolve: resolve7 } = __require("path");
     var { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = __require("timers");
     var { InvalidArgumentError, UndiciError } = require_errors();
     var { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } = require_snapshot_utils();
@@ -20069,12 +20069,12 @@ var require_snapshot_recorder = __commonJS({
           throw new InvalidArgumentError("Snapshot path is required");
         }
         const resolvedPath = resolve7(path);
-        await mkdir2(dirname4(resolvedPath), { recursive: true });
+        await mkdir2(dirname6(resolvedPath), { recursive: true });
         const data2 = Array.from(this.#snapshots.entries()).map(([hash, snapshot]) => ({
           hash,
           snapshot
         }));
-        await writeFile7(resolvedPath, JSON.stringify(data2, null, 2), { flush: true });
+        await writeFile9(resolvedPath, JSON.stringify(data2, null, 2), { flush: true });
       }
       /**
        * Clears all recorded snapshots
@@ -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) {
@@ -74544,6 +74544,63 @@ import { Command as Command4 } from "commander";
 // src/commands/auth/index.ts
 init_esm_shims();
 
+// src/core/adaptive-help.ts
+init_esm_shims();
+var ABBREVIATED_THRESHOLD = 2;
+var MINIMAL_THRESHOLD = 5;
+var ROOT_DESCRIPTIONS = {
+  full: "Skill Recordings support agent CLI \u2014 triage, investigate, and manage customer conversations.\n\n  Getting Started:\n    1. skill auth setup        Configure 1Password secrets (Front API token, DB, etc.)\n    2. skill auth status        Verify your credentials are working\n    3. skill front inbox        See what needs attention right now\n\n  Common Workflows:\n    Triage inbox          skill front inbox \u2192 skill front triage\n    Investigate ticket    skill front conversation <id> --messages\n    Bulk cleanup          skill front bulk-archive --older-than 30d\n    Generate report       skill front report --inbox support\n    Check deploys         skill deploys\n\n  For AI Agents (Claude Code, MCP):\n    skill mcp              Start JSON-RPC server with 9 Front tools\n    skill plugin sync      Install the Claude Code plugin\n    All commands support --json for structured, HATEOAS-enriched output",
+  abbreviated: "Skill Recordings support agent CLI \u2014 triage and investigate support conversations.\n\n  Start here:\n    skill auth setup        Configure 1Password + secrets\n    skill front inbox       See what needs attention\n    skill front triage      Auto-categorize conversations\n\n  Common:\n    skill front conversation <id> --messages\n    skill front reply <id>\n    skill deploys\n    skill mcp\n",
+  minimal: "Skill Recordings support agent CLI. Try: skill front inbox, skill front triage, skill auth status. Use --help for details."
+};
+var FRONT_DESCRIPTIONS = {
+  full: "Front conversations, inboxes, tags, archival, and reporting.\n\n  Prerequisites:\n    FRONT_API_TOKEN must be set. Run: skill auth setup\n\n  Start here:\n    skill front inbox                    See unassigned conversations\n    skill front inbox support             List conversations in a specific inbox\n    skill front triage                    AI-powered categorization of inbox items\n\n  Investigate a conversation:\n    skill front conversation <id> -m      Full conversation with messages\n    skill front message <id>              Single message details + body\n\n  Take action:\n    skill front assign <id>               Assign to a teammate\n    skill front reply <id>                Draft a reply (HITL, never auto-sends)\n    skill front tag <id>                  Add a tag\n    skill front archive <id>              Archive a resolved conversation\n\n  Bulk operations:\n    skill front bulk-archive              Archive old/spam conversations\n    skill front report                    Volume + tag + sender forensics\n\n  All commands accept --json for HATEOAS-enriched output with _links and _actions.",
+  abbreviated: "Front API workflows for inbox triage and conversation actions.\n\n  Common:\n    skill front inbox\n    skill front triage\n    skill front conversation <id> -m\n    skill front reply <id>\n    skill front archive <id>\n\n  Requires FRONT_API_TOKEN (skill auth setup).",
+  minimal: "Front API commands (inbox, triage, assign, reply, archive). Requires FRONT_API_TOKEN."
+};
+var AUTH_DESCRIPTIONS = {
+  full: "Manage CLI authentication and secrets.\n\n  First time? Start here:\n    skill auth setup          Interactive wizard \u2014 connects to 1Password vault,\n                              configures FRONT_API_TOKEN, DATABASE_URL, and more.\n                              Requires: `op` CLI installed (brew install 1password-cli)\n\n  Check your setup:\n    skill auth status          Shows which secrets are configured and which are missing\n    skill auth whoami          Verify your 1Password service account identity\n\n  All Skill Recordings employees have access to the Support vault in 1Password.\n  The setup wizard handles everything \u2014 no manual token pasting needed.",
+  abbreviated: "Manage CLI authentication and 1Password secrets.\n\n  Start:\n    skill auth setup\n    skill auth status\n    skill auth whoami\n\n  Requires the 1Password CLI (`op`).",
+  minimal: "Auth and 1Password setup commands."
+};
+var INNGEST_DESCRIPTIONS = {
+  full: "Inngest event and workflow commands.\n\n  Debug pipeline runs:\n    skill inngest runs --status failed --after 1h    Recent failures\n    skill inngest events --after 12h                 Recent events\n    skill inngest investigate <run-id>                Deep-dive a specific run\n\n  Requires: INNGEST_SIGNING_KEY, INNGEST_EVENT_KEY in env",
+  abbreviated: "Inngest events and workflow runs.\n\n  Common:\n    skill inngest runs --status failed --after 1h\n    skill inngest events --after 12h\n    skill inngest investigate <run-id>\n\n  Requires INNGEST_SIGNING_KEY, INNGEST_EVENT_KEY.",
+  minimal: "Inngest events and runs debugging. Requires INNGEST_SIGNING_KEY and INNGEST_EVENT_KEY."
+};
+var GROUP_DESCRIPTIONS = {
+  root: ROOT_DESCRIPTIONS,
+  front: FRONT_DESCRIPTIONS,
+  auth: AUTH_DESCRIPTIONS,
+  inngest: INNGEST_DESCRIPTIONS
+};
+var getGroupCommandCount = (state, group) => {
+  if (group === "root") return state.totalRuns;
+  const prefix = `${group}.`;
+  let total = 0;
+  for (const [name, entry] of Object.entries(state.commands)) {
+    if (name === group || name.startsWith(prefix)) {
+      total += entry.count;
+    }
+  }
+  return total;
+};
+var resolveProficiencyLevel = (state, group) => {
+  if (!state) return "full";
+  const count = getGroupCommandCount(state, group);
+  if (count >= MINIMAL_THRESHOLD) return "minimal";
+  if (count >= ABBREVIATED_THRESHOLD) return "abbreviated";
+  return "full";
+};
+var getAdaptiveDescription = (group, state) => {
+  const level = resolveProficiencyLevel(state, group);
+  return GROUP_DESCRIPTIONS[group][level];
+};
+var getRootAdaptiveDescription = (state) => getAdaptiveDescription("root", state);
+var getFrontAdaptiveDescription = (state) => getAdaptiveDescription("front", state);
+var getAuthAdaptiveDescription = (state) => getAdaptiveDescription("auth", state);
+var getInngestAdaptiveDescription = (state) => getAdaptiveDescription("inngest", state);
+
 // src/core/context.ts
 init_esm_shims();
 
@@ -74776,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
@@ -75582,8 +75639,8 @@ var buildContext = async (command, json) => {
     quiet: opts.quiet
   });
 };
-function registerAuthCommands(program3) {
-  const auth = program3.command("auth").description("Manage CLI auth status");
+function registerAuthCommands(program3, usageState2) {
+  const auth = program3.command("auth").description(getAuthAdaptiveDescription(usageState2));
   auth.command("status").description("Show active auth provider and secret availability").option("--json", "Output as JSON").action(async (options, command) => {
     const ctx = await buildContext(command, options.json);
     await statusAction(ctx, options);
@@ -96087,8 +96144,8 @@ async function getTeammate(ctx, id, options) {
     process.exitCode = cliError.exitCode;
   }
 }
-function registerFrontCommands(program3) {
-  const front = program3.command("front").description("Front conversations, inboxes, tags, archival, and reporting");
+function registerFrontCommands(program3, usageState2) {
+  const front = program3.command("front").description(getFrontAdaptiveDescription(usageState2));
   front.command("message").description("Get a message by ID (body, author, recipients, attachments)").argument("<id>", "Message ID (e.g., msg_xxx)").option("--json", "Output as JSON").action(
     async (id, options, command) => {
       const opts = typeof command.optsWithGlobals === "function" ? command.optsWithGlobals() : {
@@ -97377,8 +97434,8 @@ function registerSignalCommand(inngest) {
 }
 
 // src/commands/inngest/index.ts
-function registerInngestCommands(program3) {
-  const inngest = program3.command("inngest").description("Inngest API commands");
+function registerInngestCommands(program3, usageState2) {
+  const inngest = program3.command("inngest").description(getInngestAdaptiveDescription(usageState2));
   registerEventsCommands(inngest);
   registerRunsCommands(inngest);
   registerSignalCommand(inngest);
@@ -113409,297 +113466,2731 @@ function registerKbCommands(program3) {
   });
 }
 
-// src/commands/memory/index.ts
+// src/commands/linear/index.ts
 init_esm_shims();
 
-// src/commands/memory/find.ts
+// src/commands/linear/assign.ts
 init_esm_shims();
-var handleMemoryError = (ctx, error, message, suggestion = "Verify memory service configuration and try again.") => {
-  const cliError = error instanceof CLIError ? error : new CLIError({
-    userMessage: message,
-    suggestion,
-    cause: error
-  });
-  ctx.output.error(formatError(cliError));
-  process.exitCode = cliError.exitCode;
-};
-function pad2(str2, width) {
-  return str2.padEnd(width).slice(0, width);
+
+// 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 });
 }
-function formatConfidence(confidence) {
-  return `${(confidence * 100).toFixed(0)}%`;
+
+// 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 ?? []
+  };
 }
-async function find5(ctx, query, options) {
-  const outputJson = options.json === true || ctx.format === "json";
+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 limit2 = options.limit ? parseInt(options.limit, 10) : 10;
-    const threshold = options.minConfidence ? parseFloat(options.minConfidence) : 0.5;
-    if (limit2 < 1 || limit2 > 100 || Number.isNaN(limit2)) {
+    const client = getLinearClient();
+    const issue = await client.issue(issueId);
+    if (!issue) {
       throw new CLIError({
-        userMessage: "--limit must be between 1 and 100.",
-        suggestion: "Choose a value between 1 and 100 (default: 10)."
+        userMessage: `Issue not found: ${issueId}`,
+        suggestion: "Use `skill linear issues --json` to list available issues.",
+        exitCode: 1
       });
     }
-    if (threshold < 0 || threshold > 1 || Number.isNaN(threshold)) {
-      throw new CLIError({
-        userMessage: "--min-confidence must be between 0 and 1.",
-        suggestion: "Choose a value between 0 and 1 (default: 0.5)."
-      });
+    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;
+      }
     }
-    const results = await MemoryService.find(query, {
-      collection: options.collection || "learnings",
-      limit: limit2,
-      threshold,
-      app_slug: options.app
+    await client.updateIssue(issue.id, {
+      assigneeId: assigneeId || void 0
     });
-    if (outputJson) {
-      ctx.output.data(results);
+    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;
     }
-    if (results.length === 0) {
-      ctx.output.data("No memories found.");
-      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(`
-Found ${results.length} memories:
-`);
-    ctx.output.data(
-      pad2("ID", 36) + " " + pad2("SCORE", 8) + " " + pad2("CONF", 6) + " " + pad2("AGE", 8) + " CONTENT"
-    );
-    ctx.output.data("-".repeat(100));
-    for (const result of results) {
-      const confidence = calculateConfidence(result.memory);
-      const ageDays = Math.floor(result.age_days);
-      const ageStr = ageDays === 0 ? "today" : ageDays === 1 ? "1 day" : `${ageDays} days`;
-      const contentPreview = result.memory.content.length > 40 ? result.memory.content.slice(0, 37) + "..." : result.memory.content;
+    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(
-        pad2(result.memory.id, 36) + " " + pad2(result.score.toFixed(2), 8) + " " + pad2(formatConfidence(confidence), 6) + " " + pad2(ageStr, 8) + " " + contentPreview
+        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
+        )
       );
-      if (result.memory.metadata.tags && result.memory.metadata.tags.length > 0) {
-        ctx.output.data(
-          pad2("", 36) + " " + pad2("", 8) + " " + pad2("", 6) + " " + pad2("", 8) + ` Tags: ${result.memory.metadata.tags.join(", ")}`
-        );
-      }
+      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) {
-    handleMemoryError(ctx, error, "Failed to search memories.");
+    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/memory/get.ts
+// src/commands/linear/comment.ts
 init_esm_shims();
-var handleMemoryError2 = (ctx, error, message, suggestion = "Verify memory service configuration and try again.") => {
-  const cliError = error instanceof CLIError ? error : new CLIError({
-    userMessage: message,
-    suggestion,
-    cause: error
-  });
-  ctx.output.error(formatError(cliError));
-  process.exitCode = cliError.exitCode;
-};
-async function get2(ctx, id, options) {
-  const outputJson = options.json === true || ctx.format === "json";
+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 memory = await MemoryService.get(
-      id,
-      options.collection || "learnings"
-    );
-    if (!memory) {
+    const client = getLinearClient();
+    const issue = await client.issue(issueId);
+    if (!issue) {
       throw new CLIError({
-        userMessage: "Memory not found.",
-        suggestion: "Verify the memory ID and collection."
+        userMessage: `Issue not found: ${issueId}`,
+        suggestion: "Use `skill linear issues --json` to list available issues.",
+        exitCode: 1
       });
     }
-    if (outputJson) {
-      ctx.output.data(memory);
-      return;
-    }
-    const confidence = calculateConfidence(memory);
-    const createdAt = new Date(memory.metadata.created_at);
-    const lastValidated = memory.metadata.last_validated_at ? new Date(memory.metadata.last_validated_at) : null;
-    ctx.output.data("\n\u{1F4CB} Memory Details:");
-    ctx.output.data(`   ID:         ${memory.id}`);
-    ctx.output.data(`   Collection: ${memory.metadata.collection}`);
-    ctx.output.data(`   Source:     ${memory.metadata.source}`);
-    ctx.output.data(`   Confidence: ${(confidence * 100).toFixed(0)}%`);
-    ctx.output.data(`   Created:    ${createdAt.toLocaleString()}`);
-    if (lastValidated) {
-      ctx.output.data(`   Validated:  ${lastValidated.toLocaleString()}`);
+    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
+      });
     }
-    if (memory.metadata.app_slug) {
-      ctx.output.data(`   App:        ${memory.metadata.app_slug}`);
+    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;
     }
-    if (memory.metadata.tags && memory.metadata.tags.length > 0) {
-      ctx.output.data(`   Tags:       ${memory.metadata.tags.join(", ")}`);
+    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}`);
     }
-    ctx.output.data("\n\u{1F4DD} Content:");
-    ctx.output.data(`   ${memory.content}
-`);
-    if (memory.metadata.votes) {
-      const { upvotes, downvotes, citations, success_rate } = memory.metadata.votes;
-      if (upvotes > 0 || downvotes > 0 || citations > 0) {
-        ctx.output.data("\u{1F4CA} Votes:");
-        ctx.output.data(`   Upvotes:      ${upvotes}`);
-        ctx.output.data(`   Downvotes:    ${downvotes}`);
-        ctx.output.data(`   Citations:    ${citations}`);
-        ctx.output.data(
-          `   Success Rate: ${(success_rate * 100).toFixed(0)}%
-`
-        );
-      }
+    if (bodyLines.length > 10) {
+      ctx.output.data(`   ... (${bodyLines.length - 10} more lines)`);
     }
+    ctx.output.data("");
   } catch (error) {
-    handleMemoryError2(ctx, error, "Failed to fetch memory.");
+    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/memory/stats.ts
+// src/commands/linear/comments.ts
 init_esm_shims();
-var handleMemoryError3 = (ctx, error, message, suggestion = "Verify memory service configuration and try again.") => {
-  const cliError = error instanceof CLIError ? error : new CLIError({
-    userMessage: message,
-    suggestion,
-    cause: error
-  });
-  ctx.output.error(formatError(cliError));
-  process.exitCode = cliError.exitCode;
-};
-async function stats3(ctx, options) {
-  const outputJson = options.json === true || ctx.format === "json";
+async function listComments(ctx, issueId, options = {}) {
+  const limit2 = options.limit || 50;
   try {
-    const statsResult = await VotingService.stats(options.collection);
-    if (outputJson) {
-      ctx.output.data(statsResult);
-      return;
-    }
-    const collections = Object.keys(statsResult);
-    if (collections.length === 0) {
-      ctx.output.data("No memories found");
-      return;
+    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
+      });
     }
-    ctx.output.data("\nMemory Statistics");
-    ctx.output.data("\u2500".repeat(60));
-    for (const collection of collections) {
-      const stats4 = statsResult[collection];
-      if (!stats4) continue;
-      ctx.output.data(`
-${collection}:`);
-      ctx.output.data(`  Total memories: ${stats4.count}`);
+    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(
-        `  Avg confidence: ${(stats4.avg_confidence * 100).toFixed(1)}%`
+        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
+        )
       );
-      ctx.output.data(`  Upvotes: ${stats4.total_upvotes}`);
-      ctx.output.data(`  Downvotes: ${stats4.total_downvotes}`);
-      ctx.output.data(`  Citations: ${stats4.total_citations}`);
+      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(
-        `  Avg success rate: ${(stats4.avg_success_rate * 100).toFixed(1)}%`
+        `   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) {
-    handleMemoryError3(ctx, error, "Failed to fetch memory statistics.");
+    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;
   }
 }
-async function stale(ctx, options) {
-  const outputJson = options.json === true || ctx.format === "json";
+
+// 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 threshold = options.threshold ?? 0.25;
-    if (threshold < 0 || threshold > 1 || Number.isNaN(threshold)) {
-      throw new CLIError({
-        userMessage: "--threshold must be between 0 and 1.",
-        suggestion: "Choose a value between 0 and 1 (default: 0.25)."
-      });
+    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;
     }
-    const collections = options.collection ? [options.collection] : await VotingService._listCollections();
-    const staleMemories = [];
-    for (const collection of collections) {
-      const memories = await VotingService._fetchAllMemories(collection);
-      for (const memory of memories) {
-        const confidence = calculateConfidence(memory);
-        if (confidence < threshold) {
-          const createdAt = new Date(memory.metadata.created_at);
-          const lastValidatedAt = memory.metadata.last_validated_at ? new Date(memory.metadata.last_validated_at) : void 0;
-          const referenceDate = lastValidatedAt || createdAt;
-          const ageDays = (Date.now() - referenceDate.getTime()) / (24 * 60 * 60 * 1e3);
-          const contentPreview = memory.content.length > 60 ? memory.content.slice(0, 57) + "..." : memory.content;
-          staleMemories.push({
-            id: memory.id,
-            collection,
-            confidence,
-            age_days: ageDays,
-            content_preview: contentPreview
+    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;
       }
     }
-    if (outputJson) {
-      ctx.output.data(staleMemories);
-      return;
+    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);
+      }
     }
-    if (staleMemories.length === 0) {
+    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(
-        `No stale memories found (threshold: ${(threshold * 100).toFixed(0)}%)`
+        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(
-      `
-Stale Memories (confidence < ${(threshold * 100).toFixed(0)}%)`
+      `     \u2022 Assign:  skill linear assign ${issue.identifier} --to <email>`
+    );
+    ctx.output.data(
+      `     \u2022 Comment: skill linear comment ${issue.identifier} --body "text"`
     );
-    ctx.output.data("\u2500".repeat(80));
-    for (const mem of staleMemories) {
-      ctx.output.data(`
-${mem.id} [${mem.collection}]`);
-      ctx.output.data(`  Confidence: ${(mem.confidence * 100).toFixed(1)}%`);
-      ctx.output.data(`  Age: ${mem.age_days.toFixed(1)} days`);
-      ctx.output.data(`  Preview: ${mem.content_preview}`);
-    }
     ctx.output.data("");
   } catch (error) {
-    handleMemoryError3(ctx, error, "Failed to fetch stale memories.");
+    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/memory/store.ts
+// src/commands/linear/get.ts
 init_esm_shims();
-var handleMemoryError4 = (ctx, error, message, suggestion = "Verify memory service configuration and try again.") => {
-  const cliError = error instanceof CLIError ? error : new CLIError({
-    userMessage: message,
-    suggestion,
-    cause: error
-  });
-  ctx.output.error(formatError(cliError));
-  process.exitCode = cliError.exitCode;
+var PRIORITY_LABELS = {
+  0: "Urgent",
+  1: "High",
+  2: "Medium",
+  3: "Low",
+  4: "None"
 };
-async function store(ctx, content, options) {
-  const outputJson = options.json === true || ctx.format === "json";
+var PRIORITY_EMOJI = {
+  0: "\u{1F534}",
+  1: "\u{1F7E0}",
+  2: "\u{1F7E1}",
+  3: "\u{1F7E2}",
+  4: "\u26AA"
+};
+async function getIssue(ctx, id) {
   try {
-    const memory = await MemoryService.store(content, {
-      collection: options.collection || "learnings",
-      source: "human",
-      app_slug: options.app,
-      tags: options.tags?.split(",").map((t2) => t2.trim()) ?? []
-    });
-    if (outputJson) {
-      ctx.output.data(memory);
+    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(`\u2713 Stored memory: ${memory.id}`);
-    if (memory.metadata.tags && memory.metadata.tags.length > 0) {
-      ctx.output.data(`  Tags: ${memory.metadata.tags.join(", ")}`);
+    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 (memory.metadata.app_slug) {
-      ctx.output.data(`  App: ${memory.metadata.app_slug}`);
+    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) {
-    handleMemoryError4(ctx, error, "Failed to store memory.");
+    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/memory/vote.ts
+// src/commands/linear/label.ts
 init_esm_shims();
-var handleMemoryError5 = (ctx, error, message, suggestion = "Verify memory service configuration and try again.") => {
+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();
+
+// src/commands/memory/find.ts
+init_esm_shims();
+var handleMemoryError = (ctx, error, message, suggestion = "Verify memory service configuration and try again.") => {
+  const cliError = error instanceof CLIError ? error : new CLIError({
+    userMessage: message,
+    suggestion,
+    cause: error
+  });
+  ctx.output.error(formatError(cliError));
+  process.exitCode = cliError.exitCode;
+};
+function pad2(str2, width) {
+  return str2.padEnd(width).slice(0, width);
+}
+function formatConfidence(confidence) {
+  return `${(confidence * 100).toFixed(0)}%`;
+}
+async function find5(ctx, query, options) {
+  const outputJson = options.json === true || ctx.format === "json";
+  try {
+    const limit2 = options.limit ? parseInt(options.limit, 10) : 10;
+    const threshold = options.minConfidence ? parseFloat(options.minConfidence) : 0.5;
+    if (limit2 < 1 || limit2 > 100 || Number.isNaN(limit2)) {
+      throw new CLIError({
+        userMessage: "--limit must be between 1 and 100.",
+        suggestion: "Choose a value between 1 and 100 (default: 10)."
+      });
+    }
+    if (threshold < 0 || threshold > 1 || Number.isNaN(threshold)) {
+      throw new CLIError({
+        userMessage: "--min-confidence must be between 0 and 1.",
+        suggestion: "Choose a value between 0 and 1 (default: 0.5)."
+      });
+    }
+    const results = await MemoryService.find(query, {
+      collection: options.collection || "learnings",
+      limit: limit2,
+      threshold,
+      app_slug: options.app
+    });
+    if (outputJson) {
+      ctx.output.data(results);
+      return;
+    }
+    if (results.length === 0) {
+      ctx.output.data("No memories found.");
+      return;
+    }
+    ctx.output.data(`
+Found ${results.length} memories:
+`);
+    ctx.output.data(
+      pad2("ID", 36) + " " + pad2("SCORE", 8) + " " + pad2("CONF", 6) + " " + pad2("AGE", 8) + " CONTENT"
+    );
+    ctx.output.data("-".repeat(100));
+    for (const result of results) {
+      const confidence = calculateConfidence(result.memory);
+      const ageDays = Math.floor(result.age_days);
+      const ageStr = ageDays === 0 ? "today" : ageDays === 1 ? "1 day" : `${ageDays} days`;
+      const contentPreview = result.memory.content.length > 40 ? result.memory.content.slice(0, 37) + "..." : result.memory.content;
+      ctx.output.data(
+        pad2(result.memory.id, 36) + " " + pad2(result.score.toFixed(2), 8) + " " + pad2(formatConfidence(confidence), 6) + " " + pad2(ageStr, 8) + " " + contentPreview
+      );
+      if (result.memory.metadata.tags && result.memory.metadata.tags.length > 0) {
+        ctx.output.data(
+          pad2("", 36) + " " + pad2("", 8) + " " + pad2("", 6) + " " + pad2("", 8) + ` Tags: ${result.memory.metadata.tags.join(", ")}`
+        );
+      }
+    }
+    ctx.output.data("");
+  } catch (error) {
+    handleMemoryError(ctx, error, "Failed to search memories.");
+  }
+}
+
+// src/commands/memory/get.ts
+init_esm_shims();
+var handleMemoryError2 = (ctx, error, message, suggestion = "Verify memory service configuration and try again.") => {
+  const cliError = error instanceof CLIError ? error : new CLIError({
+    userMessage: message,
+    suggestion,
+    cause: error
+  });
+  ctx.output.error(formatError(cliError));
+  process.exitCode = cliError.exitCode;
+};
+async function get2(ctx, id, options) {
+  const outputJson = options.json === true || ctx.format === "json";
+  try {
+    const memory = await MemoryService.get(
+      id,
+      options.collection || "learnings"
+    );
+    if (!memory) {
+      throw new CLIError({
+        userMessage: "Memory not found.",
+        suggestion: "Verify the memory ID and collection."
+      });
+    }
+    if (outputJson) {
+      ctx.output.data(memory);
+      return;
+    }
+    const confidence = calculateConfidence(memory);
+    const createdAt = new Date(memory.metadata.created_at);
+    const lastValidated = memory.metadata.last_validated_at ? new Date(memory.metadata.last_validated_at) : null;
+    ctx.output.data("\n\u{1F4CB} Memory Details:");
+    ctx.output.data(`   ID:         ${memory.id}`);
+    ctx.output.data(`   Collection: ${memory.metadata.collection}`);
+    ctx.output.data(`   Source:     ${memory.metadata.source}`);
+    ctx.output.data(`   Confidence: ${(confidence * 100).toFixed(0)}%`);
+    ctx.output.data(`   Created:    ${createdAt.toLocaleString()}`);
+    if (lastValidated) {
+      ctx.output.data(`   Validated:  ${lastValidated.toLocaleString()}`);
+    }
+    if (memory.metadata.app_slug) {
+      ctx.output.data(`   App:        ${memory.metadata.app_slug}`);
+    }
+    if (memory.metadata.tags && memory.metadata.tags.length > 0) {
+      ctx.output.data(`   Tags:       ${memory.metadata.tags.join(", ")}`);
+    }
+    ctx.output.data("\n\u{1F4DD} Content:");
+    ctx.output.data(`   ${memory.content}
+`);
+    if (memory.metadata.votes) {
+      const { upvotes, downvotes, citations, success_rate } = memory.metadata.votes;
+      if (upvotes > 0 || downvotes > 0 || citations > 0) {
+        ctx.output.data("\u{1F4CA} Votes:");
+        ctx.output.data(`   Upvotes:      ${upvotes}`);
+        ctx.output.data(`   Downvotes:    ${downvotes}`);
+        ctx.output.data(`   Citations:    ${citations}`);
+        ctx.output.data(
+          `   Success Rate: ${(success_rate * 100).toFixed(0)}%
+`
+        );
+      }
+    }
+  } catch (error) {
+    handleMemoryError2(ctx, error, "Failed to fetch memory.");
+  }
+}
+
+// src/commands/memory/stats.ts
+init_esm_shims();
+var handleMemoryError3 = (ctx, error, message, suggestion = "Verify memory service configuration and try again.") => {
+  const cliError = error instanceof CLIError ? error : new CLIError({
+    userMessage: message,
+    suggestion,
+    cause: error
+  });
+  ctx.output.error(formatError(cliError));
+  process.exitCode = cliError.exitCode;
+};
+async function stats3(ctx, options) {
+  const outputJson = options.json === true || ctx.format === "json";
+  try {
+    const statsResult = await VotingService.stats(options.collection);
+    if (outputJson) {
+      ctx.output.data(statsResult);
+      return;
+    }
+    const collections = Object.keys(statsResult);
+    if (collections.length === 0) {
+      ctx.output.data("No memories found");
+      return;
+    }
+    ctx.output.data("\nMemory Statistics");
+    ctx.output.data("\u2500".repeat(60));
+    for (const collection of collections) {
+      const stats4 = statsResult[collection];
+      if (!stats4) continue;
+      ctx.output.data(`
+${collection}:`);
+      ctx.output.data(`  Total memories: ${stats4.count}`);
+      ctx.output.data(
+        `  Avg confidence: ${(stats4.avg_confidence * 100).toFixed(1)}%`
+      );
+      ctx.output.data(`  Upvotes: ${stats4.total_upvotes}`);
+      ctx.output.data(`  Downvotes: ${stats4.total_downvotes}`);
+      ctx.output.data(`  Citations: ${stats4.total_citations}`);
+      ctx.output.data(
+        `  Avg success rate: ${(stats4.avg_success_rate * 100).toFixed(1)}%`
+      );
+    }
+    ctx.output.data("");
+  } catch (error) {
+    handleMemoryError3(ctx, error, "Failed to fetch memory statistics.");
+  }
+}
+async function stale(ctx, options) {
+  const outputJson = options.json === true || ctx.format === "json";
+  try {
+    const threshold = options.threshold ?? 0.25;
+    if (threshold < 0 || threshold > 1 || Number.isNaN(threshold)) {
+      throw new CLIError({
+        userMessage: "--threshold must be between 0 and 1.",
+        suggestion: "Choose a value between 0 and 1 (default: 0.25)."
+      });
+    }
+    const collections = options.collection ? [options.collection] : await VotingService._listCollections();
+    const staleMemories = [];
+    for (const collection of collections) {
+      const memories = await VotingService._fetchAllMemories(collection);
+      for (const memory of memories) {
+        const confidence = calculateConfidence(memory);
+        if (confidence < threshold) {
+          const createdAt = new Date(memory.metadata.created_at);
+          const lastValidatedAt = memory.metadata.last_validated_at ? new Date(memory.metadata.last_validated_at) : void 0;
+          const referenceDate = lastValidatedAt || createdAt;
+          const ageDays = (Date.now() - referenceDate.getTime()) / (24 * 60 * 60 * 1e3);
+          const contentPreview = memory.content.length > 60 ? memory.content.slice(0, 57) + "..." : memory.content;
+          staleMemories.push({
+            id: memory.id,
+            collection,
+            confidence,
+            age_days: ageDays,
+            content_preview: contentPreview
+          });
+        }
+      }
+    }
+    if (outputJson) {
+      ctx.output.data(staleMemories);
+      return;
+    }
+    if (staleMemories.length === 0) {
+      ctx.output.data(
+        `No stale memories found (threshold: ${(threshold * 100).toFixed(0)}%)`
+      );
+      return;
+    }
+    ctx.output.data(
+      `
+Stale Memories (confidence < ${(threshold * 100).toFixed(0)}%)`
+    );
+    ctx.output.data("\u2500".repeat(80));
+    for (const mem of staleMemories) {
+      ctx.output.data(`
+${mem.id} [${mem.collection}]`);
+      ctx.output.data(`  Confidence: ${(mem.confidence * 100).toFixed(1)}%`);
+      ctx.output.data(`  Age: ${mem.age_days.toFixed(1)} days`);
+      ctx.output.data(`  Preview: ${mem.content_preview}`);
+    }
+    ctx.output.data("");
+  } catch (error) {
+    handleMemoryError3(ctx, error, "Failed to fetch stale memories.");
+  }
+}
+
+// src/commands/memory/store.ts
+init_esm_shims();
+var handleMemoryError4 = (ctx, error, message, suggestion = "Verify memory service configuration and try again.") => {
+  const cliError = error instanceof CLIError ? error : new CLIError({
+    userMessage: message,
+    suggestion,
+    cause: error
+  });
+  ctx.output.error(formatError(cliError));
+  process.exitCode = cliError.exitCode;
+};
+async function store(ctx, content, options) {
+  const outputJson = options.json === true || ctx.format === "json";
+  try {
+    const memory = await MemoryService.store(content, {
+      collection: options.collection || "learnings",
+      source: "human",
+      app_slug: options.app,
+      tags: options.tags?.split(",").map((t2) => t2.trim()) ?? []
+    });
+    if (outputJson) {
+      ctx.output.data(memory);
+      return;
+    }
+    ctx.output.data(`\u2713 Stored memory: ${memory.id}`);
+    if (memory.metadata.tags && memory.metadata.tags.length > 0) {
+      ctx.output.data(`  Tags: ${memory.metadata.tags.join(", ")}`);
+    }
+    if (memory.metadata.app_slug) {
+      ctx.output.data(`  App: ${memory.metadata.app_slug}`);
+    }
+  } catch (error) {
+    handleMemoryError4(ctx, error, "Failed to store memory.");
+  }
+}
+
+// src/commands/memory/vote.ts
+init_esm_shims();
+var handleMemoryError5 = (ctx, error, message, suggestion = "Verify memory service configuration and try again.") => {
   const cliError = error instanceof CLIError ? error : new CLIError({
     userMessage: message,
     suggestion,
@@ -115844,6 +118335,529 @@ async function wizard(ctx, options = {}) {
   }
 }
 
+// src/core/auto-update.ts
+init_esm_shims();
+import { spawn } from "child_process";
+import { writeFile as writeFile7 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname4, join as join12 } from "path";
+var CONFIG_DIR_NAME = "skill-cli";
+var AUTO_UPDATE_STATE_FILE = "auto-update.json";
+var DEFAULT_PACKAGE = "@skillrecordings/cli";
+var REGISTRY_BASE = "https://registry.npmjs.org/";
+var CHECK_THROTTLE_MS = 60 * 60 * 1e3;
+var UPDATE_THROTTLE_MS = 24 * 60 * 60 * 1e3;
+var AutoUpdateStore = class {
+  filePath;
+  now;
+  constructor(options = {}) {
+    const configDir = resolveConfigDir(options.configDir);
+    this.filePath = join12(configDir, AUTO_UPDATE_STATE_FILE);
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  getNow() {
+    return this.now();
+  }
+  async load() {
+    try {
+      if (await pathExists(this.filePath)) {
+        const data2 = await readJson(this.filePath);
+        if (isAutoUpdateState(data2)) return data2;
+      }
+    } catch {
+    }
+    return {};
+  }
+  async save(state) {
+    try {
+      await ensureDir(dirname4(this.filePath));
+      await writeFile7(this.filePath, JSON.stringify(state, null, 2), "utf-8");
+    } catch {
+    }
+  }
+};
+function resolveConfigDir(configDir) {
+  if (configDir) return configDir;
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+  if (xdgConfigHome && xdgConfigHome.trim() !== "") {
+    return join12(xdgConfigHome, CONFIG_DIR_NAME);
+  }
+  return join12(homedir2(), ".config", CONFIG_DIR_NAME);
+}
+function isAutoUpdateState(value) {
+  if (!value || typeof value !== "object") return false;
+  const state = value;
+  if (state.lastCheckAt !== void 0 && typeof state.lastCheckAt !== "string") {
+    return false;
+  }
+  if (state.lastUpdateAt !== void 0 && typeof state.lastUpdateAt !== "string") {
+    return false;
+  }
+  if (state.lastKnownVersion !== void 0 && typeof state.lastKnownVersion !== "string") {
+    return false;
+  }
+  return true;
+}
+function isAutoUpdateDisabled() {
+  return process.env.SKILL_NO_AUTO_UPDATE === "1";
+}
+function isWithinWindow(timestamp, now, windowMs) {
+  if (!timestamp) return false;
+  const parsed = Date.parse(timestamp);
+  if (Number.isNaN(parsed)) return false;
+  return now.getTime() - parsed < windowMs;
+}
+function normalizePackageName(name) {
+  if (name.startsWith("@")) {
+    return name.replace("/", "%2F");
+  }
+  return name;
+}
+function parseSemver(version) {
+  const trimmed = version.trim().replace(/^v/, "");
+  if (!trimmed) return null;
+  const [core, prerelease] = trimmed.split("-", 2);
+  if (!core) return null;
+  const parts = core.split(".");
+  if (parts.length < 3) return null;
+  const major = Number.parseInt(parts[0] ?? "", 10);
+  const minor = Number.parseInt(parts[1] ?? "", 10);
+  const patch = Number.parseInt(parts[2] ?? "", 10);
+  if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch)) {
+    return null;
+  }
+  return { major, minor, patch, prerelease };
+}
+function compareSemver(a, b) {
+  const parsedA = parseSemver(a);
+  const parsedB = parseSemver(b);
+  if (!parsedA || !parsedB) return 0;
+  if (parsedA.major !== parsedB.major) {
+    return parsedA.major > parsedB.major ? 1 : -1;
+  }
+  if (parsedA.minor !== parsedB.minor) {
+    return parsedA.minor > parsedB.minor ? 1 : -1;
+  }
+  if (parsedA.patch !== parsedB.patch) {
+    return parsedA.patch > parsedB.patch ? 1 : -1;
+  }
+  if (parsedA.prerelease && !parsedB.prerelease) return -1;
+  if (!parsedA.prerelease && parsedB.prerelease) return 1;
+  if (parsedA.prerelease && parsedB.prerelease) {
+    if (parsedA.prerelease === parsedB.prerelease) return 0;
+    return parsedA.prerelease > parsedB.prerelease ? 1 : -1;
+  }
+  return 0;
+}
+function resolvePackageManager(userAgent) {
+  const ua = userAgent ?? process.env.npm_config_user_agent ?? "";
+  if (ua.startsWith("bun")) return "bun";
+  if (ua.includes("bun")) return "bun";
+  if (ua.startsWith("npm")) return "npm";
+  return "npm";
+}
+async function checkForUpdate(options) {
+  const packageName = options.packageName ?? DEFAULT_PACKAGE;
+  const fetchFn = options.fetchFn ?? fetch;
+  const store2 = new AutoUpdateStore({
+    configDir: options.configDir,
+    now: options.now
+  });
+  const now = store2.getNow();
+  const state = await store2.load();
+  if (isWithinWindow(state.lastCheckAt, now, CHECK_THROTTLE_MS)) {
+    const latest = state.lastKnownVersion;
+    const updateAvailable2 = latest ? compareSemver(latest, options.currentVersion) > 0 : false;
+    return { updateAvailable: updateAvailable2, latestVersion: latest, checked: false };
+  }
+  let latestVersion;
+  try {
+    const registryUrl = `${REGISTRY_BASE}${normalizePackageName(packageName)}`;
+    const response = await fetchFn(registryUrl, {
+      headers: { Accept: "application/json" }
+    });
+    if (response.ok) {
+      const data2 = await response.json();
+      latestVersion = data2["dist-tags"]?.latest;
+    }
+  } catch {
+  }
+  state.lastCheckAt = now.toISOString();
+  if (latestVersion) {
+    state.lastKnownVersion = latestVersion;
+  }
+  await store2.save(state);
+  const updateAvailable = latestVersion !== void 0 && compareSemver(latestVersion, options.currentVersion) > 0;
+  return { updateAvailable, latestVersion, checked: true };
+}
+async function performUpdate(options = {}) {
+  const packageName = options.packageName ?? DEFAULT_PACKAGE;
+  const store2 = new AutoUpdateStore({
+    configDir: options.configDir,
+    now: options.now
+  });
+  const now = store2.getNow();
+  const packageManager = resolvePackageManager(options.userAgent);
+  const spawnFn = options.spawnFn ?? spawn;
+  const [command, args] = packageManager === "bun" ? ["bun", ["add", "-g", packageName]] : ["npm", ["install", "-g", packageName]];
+  const exitCode = await new Promise((resolve7) => {
+    try {
+      const child = spawnFn(command, args, {
+        stdio: "ignore",
+        env: process.env
+      });
+      child.on("error", () => resolve7(1));
+      child.on("close", (code) => resolve7(code ?? 1));
+    } catch {
+      resolve7(1);
+    }
+  });
+  if (exitCode === 0) {
+    const state = await store2.load();
+    state.lastUpdateAt = now.toISOString();
+    await store2.save(state);
+    return true;
+  }
+  return false;
+}
+async function autoUpdateAfterCommand(options) {
+  if (isAutoUpdateDisabled()) return;
+  if (options.isDevMode) return;
+  if (options.commandName === "mcp") return;
+  if (options.format === "json") return;
+  const store2 = new AutoUpdateStore({
+    configDir: options.configDir,
+    now: options.now
+  });
+  const now = store2.getNow();
+  const state = await store2.load();
+  if (isWithinWindow(state.lastUpdateAt, now, UPDATE_THROTTLE_MS)) return;
+  const check = await (options.checkForUpdateFn ?? checkForUpdate)({
+    currentVersion: options.currentVersion,
+    packageName: options.packageName,
+    configDir: options.configDir,
+    now: options.now
+  });
+  if (!check.updateAvailable) return;
+  state.lastUpdateAt = now.toISOString();
+  await store2.save(state);
+  const updated = await (options.performUpdateFn ?? performUpdate)({
+    packageName: options.packageName,
+    configDir: options.configDir,
+    now: options.now
+  });
+  if (updated) return;
+}
+
+// src/core/hint-engine.ts
+init_esm_shims();
+var DEFAULT_MAX_HINTS = 2;
+var getCommandCount = (state, command) => state.commands[command]?.count ?? 0;
+var hasCommand = (state, command) => getCommandCount(state, command) > 0;
+var hasCommandPrefix = (state, prefix) => Object.entries(state.commands).some(
+  ([name, entry]) => name.startsWith(prefix) && entry.count > 0
+);
+var hasMilestone = (state, milestone) => state.milestones[milestone]?.achieved ?? false;
+var shouldSuppressHints = (context) => context.quiet === true || context.format === "json";
+var resolveMaxHints = (context) => context.maxHints ?? DEFAULT_MAX_HINTS;
+var toHint = (rule) => ({
+  id: rule.id,
+  message: rule.message,
+  audience: rule.audience
+});
+var DEFAULT_HINT_RULES = [
+  {
+    id: "onboarding.wizard",
+    audience: "onboarding",
+    message: "New here? Run `skill wizard` to set up your first product.",
+    showWhen: (state) => state.totalRuns <= 2 && !hasCommand(state, "wizard"),
+    retireWhen: (state) => hasCommand(state, "wizard") || hasMilestone(state, "wizard_completed")
+  },
+  {
+    id: "onboarding.auth",
+    audience: "onboarding",
+    message: "Configure credentials with `skill init` to unlock the full CLI.",
+    showWhen: (state) => state.totalRuns >= 1 && !hasMilestone(state, "auth_configured"),
+    retireWhen: (state) => hasMilestone(state, "auth_configured")
+  },
+  {
+    id: "discovery.health",
+    audience: "discovery",
+    message: "Check integrations fast with `skill health <app-slug>`.",
+    showWhen: (state) => state.totalRuns >= 2 && !hasCommand(state, "health"),
+    retireWhen: (state) => hasCommand(state, "health")
+  },
+  {
+    id: "discovery.front.inbox",
+    audience: "discovery",
+    message: "List recent conversations via `skill front inbox <name-or-id>`.",
+    showWhen: (state) => state.totalRuns >= 1 && !hasCommand(state, "front.inbox"),
+    retireWhen: (state) => hasCommand(state, "front.inbox")
+  },
+  {
+    id: "discovery.inngest",
+    audience: "discovery",
+    message: "Inspect workflows with `skill inngest stats --after 1d`.",
+    showWhen: (state) => state.totalRuns >= 3 && !hasCommandPrefix(state, "inngest."),
+    retireWhen: (state) => hasCommandPrefix(state, "inngest.")
+  },
+  {
+    id: "discovery.axiom",
+    audience: "discovery",
+    message: 'Query logs quickly with `skill axiom query "<APL>" --since 24h`.',
+    showWhen: (state) => state.totalRuns >= 3 && !hasCommandPrefix(state, "axiom."),
+    retireWhen: (state) => hasCommandPrefix(state, "axiom.")
+  },
+  {
+    id: "context.front.triage",
+    audience: "contextual",
+    postRun: true,
+    message: "Tip: `skill front triage <inbox-id>` surfaces unassigned threads.",
+    showWhen: (state, context) => context.command === "front.inbox" && !hasCommand(state, "front.triage"),
+    retireWhen: (state) => hasCommand(state, "front.triage")
+  },
+  {
+    id: "context.front.conversation",
+    audience: "contextual",
+    postRun: true,
+    message: "Tip: `skill front conversation <id> -m` shows the full thread.",
+    showWhen: (state, context) => context.command === "front.message" && !hasCommand(state, "front.conversation"),
+    retireWhen: (state) => hasCommand(state, "front.conversation")
+  },
+  {
+    id: "context.inngest.run",
+    audience: "contextual",
+    postRun: true,
+    message: "Tip: drill in with `skill inngest run <id>` or `skill inngest trace <run-id>`.",
+    showWhen: (state, context) => context.command === "inngest.failures" && !hasCommand(state, "inngest.run") && !hasCommand(state, "inngest.trace"),
+    retireWhen: (state) => hasCommand(state, "inngest.run") || hasCommand(state, "inngest.trace")
+  }
+];
+var HintEngine = class {
+  rules;
+  constructor(rules = DEFAULT_HINT_RULES) {
+    this.rules = rules;
+  }
+  getHints(state, context) {
+    if (shouldSuppressHints(context)) return [];
+    const maxHints = resolveMaxHints(context);
+    if (maxHints <= 0) return [];
+    const hints = [];
+    for (const rule of this.rules) {
+      if (rule.postRun) continue;
+      if (!rule.showWhen(state, context)) continue;
+      if (rule.retireWhen(state, context)) continue;
+      hints.push(toHint(rule));
+      if (hints.length >= maxHints) break;
+    }
+    return hints;
+  }
+  getPostRunHint(state, context) {
+    if (shouldSuppressHints(context)) return null;
+    const maxHints = resolveMaxHints(context);
+    if (maxHints <= 0) return null;
+    const previouslyShown = context.previouslyShown ?? 0;
+    if (previouslyShown >= maxHints) return null;
+    for (const rule of this.rules) {
+      if (!rule.postRun) continue;
+      if (!rule.showWhen(state, context)) continue;
+      if (rule.retireWhen(state, context)) continue;
+      return toHint(rule);
+    }
+    return null;
+  }
+};
+var writeHints = (hints, stderr) => {
+  for (const hint of hints) {
+    stderr.write(`${hint.message}
+`);
+  }
+};
+
+// src/core/telemetry.ts
+init_esm_shims();
+import { Axiom as Axiom2 } from "@axiomhq/js";
+var DEFAULT_DATASET = "support-agent";
+var axiomClient = null;
+function isTelemetryDisabled() {
+  return process.env.SKILL_NO_TELEMETRY === "1";
+}
+function getAxiomClient2() {
+  const token = process.env.AXIOM_TOKEN;
+  if (!token) return null;
+  if (!axiomClient) {
+    axiomClient = new Axiom2({ token });
+  }
+  return axiomClient;
+}
+function resolveTelemetryUser() {
+  const raw = process.env.USER ?? process.env.LOGNAME ?? process.env.USERNAME ?? "";
+  const trimmed = raw.trim();
+  if (!trimmed) return void 0;
+  const base = trimmed.split("@")[0]?.trim();
+  return base || void 0;
+}
+async function sendTelemetryEvent(event) {
+  if (isTelemetryDisabled()) return;
+  const client = getAxiomClient2();
+  if (!client) return;
+  const dataset = process.env.AXIOM_DATASET || DEFAULT_DATASET;
+  const safeEvent = {
+    command: event.command,
+    duration: event.duration,
+    success: event.success,
+    platform: event.platform,
+    user: event.user
+  };
+  try {
+    await client.ingest(dataset, {
+      _time: (/* @__PURE__ */ new Date()).toISOString(),
+      ...safeEvent
+    });
+  } catch {
+  }
+}
+
+// src/core/usage-tracker.ts
+init_esm_shims();
+import { writeFile as writeFile8 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname5, join as join13 } from "path";
+var CONFIG_DIR_NAME2 = "skill-cli";
+var USAGE_FILE_NAME = "usage.json";
+function resolveConfigDir2(configDir) {
+  if (configDir) return configDir;
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+  if (xdgConfigHome && xdgConfigHome.trim() !== "") {
+    return join13(xdgConfigHome, CONFIG_DIR_NAME2);
+  }
+  return join13(homedir3(), ".config", CONFIG_DIR_NAME2);
+}
+function createDefaultState(now) {
+  return {
+    firstRun: now.toISOString(),
+    totalRuns: 0,
+    commands: {},
+    milestones: {}
+  };
+}
+function isUsageState(value) {
+  if (!value || typeof value !== "object") return false;
+  const state = value;
+  if (typeof state.firstRun !== "string") return false;
+  if (typeof state.totalRuns !== "number") return false;
+  if (!state.commands || typeof state.commands !== "object") return false;
+  if (!state.milestones || typeof state.milestones !== "object") return false;
+  for (const entry of Object.values(state.commands)) {
+    if (!entry || typeof entry !== "object") return false;
+    if (typeof entry.count !== "number") return false;
+    if (typeof entry.firstRun !== "string") return false;
+    if (typeof entry.lastRun !== "string") return false;
+  }
+  for (const entry of Object.values(state.milestones)) {
+    if (!entry || typeof entry !== "object") return false;
+    if (typeof entry.achieved !== "boolean") return false;
+    if (entry.achievedAt !== void 0 && typeof entry.achievedAt !== "string") {
+      return false;
+    }
+  }
+  return true;
+}
+var UsageTracker = class {
+  filePath;
+  now;
+  statePromise;
+  constructor(options = {}) {
+    const configDir = resolveConfigDir2(options.configDir);
+    this.filePath = join13(configDir, USAGE_FILE_NAME);
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  async loadState() {
+    if (!this.statePromise) {
+      this.statePromise = this.loadStateInternal();
+    }
+    return this.statePromise;
+  }
+  async loadStateInternal() {
+    try {
+      if (await pathExists(this.filePath)) {
+        const data2 = await readJson(this.filePath);
+        if (isUsageState(data2)) {
+          return data2;
+        }
+      }
+    } catch {
+    }
+    return createDefaultState(this.now());
+  }
+  async saveState(state) {
+    try {
+      await ensureDir(dirname5(this.filePath));
+      await writeFile8(this.filePath, JSON.stringify(state, null, 2), "utf-8");
+    } catch {
+    }
+  }
+  async record(command, _opts = {}) {
+    const state = await this.loadState();
+    const nowIso = this.now().toISOString();
+    state.totalRuns += 1;
+    const existing = state.commands[command];
+    if (existing) {
+      existing.count += 1;
+      existing.lastRun = nowIso;
+    } else {
+      state.commands[command] = {
+        count: 1,
+        firstRun: nowIso,
+        lastRun: nowIso
+      };
+    }
+    await this.saveState(state);
+    return state;
+  }
+  async getUsage() {
+    return this.loadState();
+  }
+  async getCommandCount(command) {
+    const state = await this.loadState();
+    return state.commands[command]?.count ?? 0;
+  }
+  async hasMilestone(name) {
+    const state = await this.loadState();
+    return state.milestones[name]?.achieved ?? false;
+  }
+  async setMilestone(name) {
+    const state = await this.loadState();
+    const existing = state.milestones[name];
+    if (!existing || !existing.achieved) {
+      state.milestones[name] = {
+        achieved: true,
+        achievedAt: this.now().toISOString()
+      };
+      await this.saveState(state);
+    }
+  }
+  async totalRuns() {
+    const state = await this.loadState();
+    return state.totalRuns;
+  }
+  async daysSinceFirstRun() {
+    const state = await this.loadState();
+    const firstRunMs = Date.parse(state.firstRun);
+    if (Number.isNaN(firstRunMs)) return 0;
+    const diffMs = this.now().getTime() - firstRunMs;
+    if (diffMs <= 0) return 0;
+    return Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+  }
+};
+var cachedUsageTracker;
+function getUsageTracker() {
+  if (!cachedUsageTracker) {
+    cachedUsageTracker = new UsageTracker();
+  }
+  return cachedUsageTracker;
+}
+
 // src/mcp/server.ts
 init_esm_shims();
 import { createInterface as createInterface2 } from "readline";
@@ -116348,13 +119362,64 @@ var runtimeTarget = `bun-${process.platform}-${process.arch}`;
 var buildVersion = typeof BUILD_VERSION !== "undefined" && BUILD_VERSION.length > 0 ? BUILD_VERSION : "0.0.0-dev";
 var buildCommit = typeof BUILD_COMMIT !== "undefined" && BUILD_COMMIT.length > 0 ? BUILD_COMMIT : "dev";
 var buildTarget = typeof BUILD_TARGET !== "undefined" && BUILD_TARGET.length > 0 ? BUILD_TARGET : runtimeTarget;
+var isDevBuild = buildVersion.includes("dev") || buildCommit === "dev";
 var versionLabel = `skill v${buildVersion} (${buildCommit}) ${buildTarget}`;
 var program2 = new Command4();
-program2.name("skill").description("CLI tool for managing app integrations").version(versionLabel).option("-f, --format <format>", "Output format (json|text|table)").option("-v, --verbose", "Enable verbose output").option("-q, --quiet", "Suppress non-error output").option(
+var hintEngine = new HintEngine();
+var usageTracker = getUsageTracker();
+var usageState = await (async () => {
+  try {
+    return await usageTracker.getUsage();
+  } catch {
+    return null;
+  }
+})();
+var hintCounts = /* @__PURE__ */ new WeakMap();
+var commandStartTimes = /* @__PURE__ */ new WeakMap();
+var resolveCommandName = (command) => {
+  const names = [];
+  let current = command;
+  while (current) {
+    const name = current.name();
+    if (name) names.unshift(name);
+    current = current.parent;
+  }
+  if (names[0] === "skill") names.shift();
+  return names.join(".");
+};
+var resolveHintContext = (command) => {
+  const opts = typeof command.optsWithGlobals === "function" ? command.optsWithGlobals() : {
+    ...command.parent?.opts(),
+    ...command.opts()
+  };
+  const outputJson = opts.json === true || opts.format === "json";
+  const suppressForPipe = process.env.SKILL_CLI_FORCE_HINTS === "1" ? false : process.stdout.isTTY !== true;
+  return {
+    command: resolveCommandName(command),
+    format: outputJson ? "json" : opts.format,
+    quiet: opts.quiet === true || suppressForPipe
+  };
+};
+var resolveMilestones = (commandName) => {
+  switch (commandName) {
+    case "wizard":
+      return ["wizard_completed"];
+    case "auth.setup":
+    case "init":
+      return ["auth_configured"];
+    default:
+      return [];
+  }
+};
+program2.name("skill").description(getRootAdaptiveDescription(usageState)).version(versionLabel).option("-f, --format <format>", "Output format (json|text|table)").option("-v, --verbose", "Enable verbose output").option("-q, --quiet", "Suppress non-error output").option(
   "--rate-limit <n>",
   "Override Front API rate limit per minute",
   (v) => Number.parseInt(v, 10)
 );
+program2.addHelpText(
+  "after",
+  "\n  Need help? Start with:\n    skill auth setup            Set up credentials (1Password)\n    skill front inbox            See what needs attention\n    skill --help                 This message\n"
+);
 program2.hook("preAction", (thisCommand, actionCommand) => {
   const opts = typeof actionCommand.optsWithGlobals === "function" ? actionCommand.optsWithGlobals() : thisCommand.opts();
   const rateLimit = opts.rateLimit;
@@ -116362,18 +119427,105 @@ program2.hook("preAction", (thisCommand, actionCommand) => {
     process.env.SKILL_RATE_LIMIT = String(rateLimit);
   }
 });
+program2.hook("preAction", (_thisCommand, actionCommand) => {
+  commandStartTimes.set(actionCommand, Date.now());
+});
+program2.hook("preAction", async (_thisCommand, actionCommand) => {
+  try {
+    const context = resolveHintContext(actionCommand);
+    const state = await usageTracker.getUsage();
+    const hints = hintEngine.getHints(state, context);
+    writeHints(hints, process.stderr);
+    hintCounts.set(actionCommand, hints.length);
+  } catch {
+  }
+});
+program2.hook("postAction", async (_thisCommand, actionCommand) => {
+  try {
+    const context = resolveHintContext(actionCommand);
+    const state = await usageTracker.record(context.command);
+    const milestones = resolveMilestones(context.command);
+    for (const milestone of milestones) {
+      await usageTracker.setMilestone(milestone);
+    }
+    const previouslyShown = hintCounts.get(actionCommand) ?? 0;
+    const postHint = hintEngine.getPostRunHint(state, {
+      ...context,
+      previouslyShown
+    });
+    if (postHint) writeHints([postHint], process.stderr);
+  } catch {
+  }
+  try {
+    const startTime = commandStartTimes.get(actionCommand) ?? Date.now();
+    const duration = Math.max(0, Date.now() - startTime);
+    const exitCode = process.exitCode ?? 0;
+    const commandName = resolveCommandName(actionCommand);
+    void sendTelemetryEvent({
+      command: commandName,
+      duration,
+      success: exitCode === 0,
+      platform: process.platform,
+      user: resolveTelemetryUser()
+    });
+  } catch {
+  }
+  try {
+    const context = resolveHintContext(actionCommand);
+    await autoUpdateAfterCommand({
+      commandName: context.command,
+      currentVersion: buildVersion,
+      format: context.format,
+      isDevMode: isDevBuild
+    });
+  } catch {
+  }
+});
 program2.command("init").description("Initialize a new app integration (quick mode)").argument(
   "[name]",
   "Name of the integration (required in non-interactive mode)"
-).option("--json", "Output result as JSON (machine-readable)").action(init2);
-program2.command("wizard").description("Interactive wizard for setting up a new property").option("--json", "Output result as JSON (machine-readable)").action(wizard);
+).option("--json", "Output result as JSON (machine-readable)").action(async (name, options, command) => {
+  const opts = typeof command.optsWithGlobals === "function" ? command.optsWithGlobals() : {
+    ...command.parent?.opts(),
+    ...command.opts()
+  };
+  const ctx = await createContext({
+    format: options.json ? "json" : opts.format,
+    verbose: opts.verbose,
+    quiet: opts.quiet
+  });
+  await init2(ctx, name, options);
+});
+program2.command("wizard").description("Interactive wizard for setting up a new property").option("--json", "Output result as JSON (machine-readable)").action(async (options, command) => {
+  const opts = typeof command.optsWithGlobals === "function" ? command.optsWithGlobals() : {
+    ...command.parent?.opts(),
+    ...command.opts()
+  };
+  const ctx = await createContext({
+    format: options.json ? "json" : opts.format,
+    verbose: opts.verbose,
+    quiet: opts.quiet
+  });
+  await wizard(ctx, options);
+});
 program2.command("health").description("Test integration endpoint health").argument(
   "[slug|url]",
   "App slug (from database) or URL (e.g., https://totaltypescript.com)"
 ).option(
   "-s, --secret <secret>",
   "Webhook secret (required for direct URL mode)"
-).option("-l, --list", "List all registered apps").option("--ids-only", "Output only IDs (one per line)").option("--json", "Output result as JSON (machine-readable)").action(health2);
+).option("-l, --list", "List all registered apps").option("--ids-only", "Output only IDs (one per line)").option("--json", "Output result as JSON (machine-readable)").action(async (slugOrUrl, options, command) => {
+  const opts = typeof command.optsWithGlobals === "function" ? command.optsWithGlobals() : {
+    ...command.parent?.opts(),
+    ...command.opts()
+  };
+  const ctx = await createContext({
+    format: options.json ? "json" : opts.format,
+    verbose: opts.verbose,
+    quiet: opts.quiet
+  });
+  await health2(ctx, slugOrUrl, options);
+});
 program2.command("eval").description("Run evals against a dataset").argument("<type>", "Eval type (e.g., routing)").argument("<dataset>", "Path to dataset JSON file").option("--json", "Output result as JSON (machine-readable)").option(
   "--min-precision <number>",
   "Minimum precision threshold (default: 0.92)",
@@ -116410,8 +119562,8 @@ program2.command("eval").description("Run evals against a dataset").argument("<t
   });
 });
 registerDbStatusCommand(program2);
-registerFrontCommands(program2);
-registerInngestCommands(program2);
+registerFrontCommands(program2, usageState);
+registerInngestCommands(program2, usageState);
 registerAxiomCommands(program2);
 registerEvalLocalCommands(program2);
 registerEvalPipelineCommands(program2);
@@ -116421,12 +119573,15 @@ registerDatasetCommands(program2);
 registerResponseCommands(program2);
 registerToolsCommands(program2);
 registerMemoryCommands(program2);
+registerLinearCommands(program2);
 registerFaqCommands(program2);
 registerDeployCommands(program2);
 registerKbCommands(program2);
-registerAuthCommands(program2);
+registerAuthCommands(program2, usageState);
 registerPluginSyncCommand(program2);
-program2.command("mcp").description("Start MCP server for AI coding agent integration").action(async () => {
+program2.command("mcp").description(
+  "Start MCP server for AI coding agent integration.\n  Exposes 9 Front tools over JSON-RPC stdio for Claude Code, Cursor, etc.\n  Tools: inbox, conversation, message, assign, reply, tag, archive, search, report\n  Usage: skill mcp  (then connect your AI editor to stdin/stdout)"
+).action(async () => {
   const server = createMcpServer();
   await server.start();
 });